mujoco_rs/wrappers/

mj_model.rs

//! MjModel related.
use crate::{
    view_creator, info_method, info_with_view,
    array_slice_dyn, getter_setter
};
use crate::util::{assert_mujoco_version, checked_c_len, ERROR_BUF_LEN};
use crate::error::{MjDataError, MjModelError};
use crate::wrappers::mj_option::MjOption;
use crate::wrappers::mj_data::MjData;
use crate::mujoco_c::*;

use super::mj_auxiliary::{MjVfs, MjVisual, MjStatistic};
use super::mj_editing::encode;
use super::mj_primitive::*;

use bytemuck::must_cast_slice;
use log::debug;

use std::fmt::{Formatter, Debug, Result as FmtResult};
use std::ffi::{c_char, CStr, CString, c_int, c_void};
use std::sync::{OnceLock, Arc};
use std::ptr::{self, NonNull};
use std::path::Path;

pub mod traits;


/*******************************************/
// Types
/// Constants which are powers of 2. They are used as bitmasks for the field `disableflags` of `mjOption`.
/// At runtime this field is `m->opt.disableflags`. The number of these constants is given by `mjNDISABLE` which is
/// also the length of the global string array `mjDISABLESTRING` with text descriptions of these flags.
pub type MjtDisableBit = mjtDisableBit;

/// Constants which are powers of 2. They are used as bitmasks for the field `enableflags` of `mjOption`.
/// At runtime this field is `m->opt.enableflags`. The number of these constants is given by `mjNENABLE` which is also
/// the length of the global string array `mjENABLESTRING` with text descriptions of these flags.
pub type MjtEnableBit = mjtEnableBit;

/// Primitive joint types. These values are used in `m->jnt_type`. The numbers in the comments indicate how many
/// positional coordinates each joint type has. Note that ball joints and rotational components of free joints are
/// represented as unit quaternions - which have 4 positional coordinates but 3 degrees of freedom each.
pub type MjtJoint = mjtJoint;

/// Geometric types supported by MuJoCo. The first group are "official" geom types that can be used in the model. The
/// second group are geom types that cannot be used in the model but are used by the visualizer to add decorative
/// elements. These values are used in `m->geom_type` and `m->site_type`.
pub type MjtGeom = mjtGeom;

/// Type of camera projection. Used in `m->cam_projection`.
pub type MjtProjection = mjtProjection;

/// Dynamic modes for cameras and lights, specifying how the camera/light position and orientation are computed. These
/// values are used in `m->cam_mode` and `m->light_mode`.
pub type MjtCamLight = mjtCamLight;

/// The type of a light source describing how its position, orientation and other properties will interact with the
/// objects in the scene. These values are used in `m->light_type`.
pub type MjtLightType = mjtLightType;

/// Texture types, specifying how the texture will be mapped. These values are used in `m->tex_type`.
pub type MjtTexture = mjtTexture;

/// Texture roles, specifying how the renderer should interpret the texture.  Note that the MuJoCo built-in renderer only
/// uses RGB textures.  These values are used to store the texture index in the material's array `m->mat_texid`.
pub type MjtTextureRole = mjtTextureRole;

/// Type of color space encoding for textures.
pub type MjtColorSpace = mjtColorSpace;

/// Mode for actuator length-range computation.
pub type MjtLRMode = mjtLRMode;

/// Cube map face indices used by [`MjsTexture::set_cubefile`](super::mj_editing::MjsTexture::set_cubefile).
///
/// Each variant corresponds to one face of a cube-map texture, matching the order
/// MuJoCo uses internally (right=0, left=1, up=2, down=3, front=4, back=5).
///
/// **Note:** this enum is defined in mujoco-rs only; MuJoCo's C API uses raw integer
/// indices for cube-map faces.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(i32)]
pub enum MjtCubeFace {
    /// Positive-X face (index 0).
    Right  = 0,
    /// Negative-X face (index 1).
    Left   = 1,
    /// Positive-Y face (index 2).
    Up     = 2,
    /// Negative-Y face (index 3).
    Down   = 3,
    /// Positive-Z face (index 4).
    Front  = 4,
    /// Negative-Z face (index 5).
    Back   = 5,
}

/// Numerical integrator types. These values are used in `m->opt.integrator`.
pub type MjtIntegrator = mjtIntegrator;

/// Available friction cone types. These values are used in `m->opt.cone`.
pub type MjtCone = mjtCone;

/// Available Jacobian types. These values are used in `m->opt.jacobian`.
pub type MjtJacobian = mjtJacobian;

/// Available constraint solver algorithms. These values are used in `m->opt.solver`.
pub type MjtSolver = mjtSolver;

/// Equality constraint types. These values are used in `m->eq_type`.
pub type MjtEq = mjtEq;

/// Tendon wrapping object types. These values are used in `m->wrap_type`.
pub type MjtWrap = mjtWrap;

/// Actuator transmission types. These values are used in `m->actuator_trntype`.
pub type MjtTrn = mjtTrn;

/// Actuator dynamics types. These values are used in `m->actuator_dyntype`.
pub type MjtDyn = mjtDyn;

/// Actuator gain types. These values are used in `m->actuator_gaintype`.
pub type MjtGain = mjtGain;

/// Actuator bias types. These values are used in `m->actuator_biastype`.
pub type MjtBias = mjtBias;

/// Orientation input charts of so3 actuators. These values are used in `m->actuator_ctrlspec`.
pub type MjtCtrlChart = mjtCtrlChart;

/// Input signature bits of servo-family (`pid`, `dcmotor`) actuators. These values are OR-ed into
/// `m->actuator_ctrlspec`.
pub type MjtCtrlInput = mjtCtrlInput;

/// MuJoCo object types. These are used, for example, in the support functions `mj_name2id` and
/// `mj_id2name` to convert between object names and integer ids.
pub type MjtObj = mjtObj;

/// Sensor types. These values are used in `m->sensor_type`.
pub type MjtSensor = mjtSensor;

/// These are the compute stages for the skipstage parameters of `mj_forwardSkip` and
/// `mj_inverseSkip`.
pub type MjtStage = mjtStage;

/// These are the possible sensor data types, used in [`MjModel::sensor_datatype`].
pub type MjtDataType = mjtDataType;

/// Types of data fields returned by contact sensors.
pub type MjtConDataField = mjtConDataField;

/// Types of frame alignment of elements with their parent bodies. Used as shortcuts during `mj_kinematics` in the
/// last argument to `mj_local2Global`.
pub type MjtSameFrame = mjtSameFrame;

/// Sleep policy associated with a tree. The compiler automatically chooses between `NEVER` and `ALLOWED`, but the user
/// can override this choice. Only the user can set the `INIT` policy (initialized as asleep).
pub type MjtSleepPolicy = mjtSleepPolicy;

/// Types of flex self-collisions midphase.
pub type MjtFlexSelf = mjtFlexSelf;

/// Formulas used to combine SDFs when calling mjc_distance and mjc_gradient.
pub type MjtSDFType = mjtSDFType;

/// Data fields returned by rangefinder sensors.
pub type MjtRayDataField = mjtRayDataField;

/// Camera output type bitflags.
pub type MjtCamOutBit = mjtCamOutBit;

// SAFETY: All MuJoCo C enums below are fieldless with an explicit integer repr, and each
// has a variant with discriminant 0, so the all-zeros bit pattern is a valid value.
// This lets `info_with_view!`'s `zero()` method use the safe `Zeroable::zeroed()`
// instead of `unsafe { std::mem::zeroed() }`, providing a compile-time guarantee
// that only safe-to-zero types are used in views.
unsafe impl bytemuck::Zeroable for mjtTrn {}
unsafe impl bytemuck::Zeroable for mjtDyn {}
unsafe impl bytemuck::Zeroable for mjtGain {}
unsafe impl bytemuck::Zeroable for mjtBias {}
unsafe impl bytemuck::Zeroable for mjtObj {}
unsafe impl bytemuck::Zeroable for mjtSameFrame {}
unsafe impl bytemuck::Zeroable for mjtCamLight {}
unsafe impl bytemuck::Zeroable for mjtProjection {}
unsafe impl bytemuck::Zeroable for mjtEq {}
unsafe impl bytemuck::Zeroable for mjtGeom {}
unsafe impl bytemuck::Zeroable for mjtJoint {}
unsafe impl bytemuck::Zeroable for mjtLightType {}
unsafe impl bytemuck::Zeroable for mjtSensor {}
unsafe impl bytemuck::Zeroable for mjtDataType {}
unsafe impl bytemuck::Zeroable for mjtStage {}
unsafe impl bytemuck::Zeroable for mjtTexture {}
unsafe impl bytemuck::Zeroable for mjtColorSpace {}
unsafe impl bytemuck::Zeroable for mjtAlignFree {}
unsafe impl bytemuck::Zeroable for mjtBuiltin {}
unsafe impl bytemuck::Zeroable for mjtConflict {}
unsafe impl bytemuck::Zeroable for mjtConstraint {}
unsafe impl bytemuck::Zeroable for mjtConstraintState {}
unsafe impl bytemuck::Zeroable for mjtDepthMap {}
unsafe impl bytemuck::Zeroable for mjtFlexSelf {}
unsafe impl bytemuck::Zeroable for mjtInertiaFromGeom {}
unsafe impl bytemuck::Zeroable for mjtLimited {}
unsafe impl bytemuck::Zeroable for mjtLogLevel {}
unsafe impl bytemuck::Zeroable for mjtLogTopic {}
unsafe impl bytemuck::Zeroable for mjtMark {}
unsafe impl bytemuck::Zeroable for mjtSleepPolicy {}
unsafe impl bytemuck::Zeroable for mjtSleepState {}
unsafe impl bytemuck::Zeroable for mjtStereo {}
unsafe impl bytemuck::Zeroable for mjtWrap {}

// SAFETY: every enum below is fieldless with a `#[repr(u32)]`, so it holds no padding and every
// byte of it is initialised. `MjSplitTables` reads these as raw bytes and never casts bytes back
// into them.
unsafe impl bytemuck::NoUninit for mjtJoint {}
unsafe impl bytemuck::NoUninit for mjtGeom {}
unsafe impl bytemuck::NoUninit for mjtEq {}
unsafe impl bytemuck::NoUninit for mjtObj {}
unsafe impl bytemuck::NoUninit for mjtWrap {}
unsafe impl bytemuck::NoUninit for mjtTrn {}
unsafe impl bytemuck::NoUninit for mjtDyn {}
unsafe impl bytemuck::NoUninit for mjtGain {}
unsafe impl bytemuck::NoUninit for mjtBias {}
unsafe impl bytemuck::NoUninit for mjtSensor {}
unsafe impl bytemuck::NoUninit for mjtDataType {}
unsafe impl bytemuck::NoUninit for mjtStage {}
unsafe impl bytemuck::NoUninit for mjtTexture {}

/*******************************************/

/// Number of mesh, texture and heightfield count tables in [`MjSplitTables`].
const ASSET_SPLIT_TABLES: usize = 11;

/// Number of per-element and plugin count tables in [`MjSplitTables`].
const ELEMENT_SPLIT_TABLES: usize = 32;

/// Snapshot of an [`MjModel`]: the sizes that no per-element table determines, and the tables that
/// fix how each packed array divides between the elements.
///
/// An entry belongs here only when no other entry already determines it. `signature` is the
/// exception: it takes no part in the comparison at all, and only reports which model an `Info`
/// came from. The fields run cheapest first, because `PartialEq` tests them in that order and
/// stops at the first difference.
// `Eq` also selects the pointer shortcut in `PartialEq for Arc`, which is what makes a view gate
// against the model's own snapshot a pointer comparison. Losing `Eq` would silently cost that.
#[derive(Debug, Clone, Eq)]
#[expect(non_snake_case, reason = "the fields keep the MuJoCo size symbol names")]
pub(crate) struct MjModelLayout {
    signature: u64,

    /* Element counts that bound an `Info` id, an `mjData` buffer row, and a swapped model. A
       count that the byte length of a table inside `split` already pins gets no field here. */
    nexclude: MjtSize,       nmat: MjtSize,           npair: MjtSize,         nskin: MjtSize,
    nkey: MjtSize,

    /* Row lengths of MJDATA_POINTERS and MJDATA_ARENA_POINTERS that no table inside `split`
       already determines. A total that is the plain sum of a count table gets no field here:
       equal tables force an equal sum, so the total follows. */
    nmocap: MjtSize,         nuserdata: MjtSize,      nhistory: MjtSize,      nbvh: MjtSize,
    nbvhdynamic: MjtSize,    nflexedge: MjtSize,      nflexstiffness: MjtSize, nJmom: MjtSize,
    nJfe: MjtSize,           nJfv: MjtSize,           nC: MjtSize,            nD: MjtSize,
    ntree: MjtSize,

    /* Byte size of the mjData arena. mjData inherits it from the model, and mj_copyDataVisual
       raises mjERROR when the destination and the source disagree. */
    narena: MjtSize,

    /* Total of the one packed mjModel array that no count table splits: qhull sizes each convex
       hull, and `mesh_graphadr` holds addresses only. Every other total is the sum of the count
       table beside it. */
    nmeshgraph: MjtSize,

    /* Strides of the per-element user arrays. */
    nuser_body: MjtSize,     nuser_jnt: MjtSize,      nuser_geom: MjtSize,    nuser_site: MjtSize,
    nuser_cam: MjtSize,      nuser_tendon: MjtSize,   nuser_actuator: MjtSize, nuser_sensor: MjtSize,

    /* Per-element count tables, byte for byte. A table pins the length of the packed array beside
       it, and it also pins how that array divides between the elements. This field sits last
       because the derived `PartialEq` tests the fields in order: every scalar above costs the same
       on any model, while a table comparison grows with the element count. */
    split: MjSplitTables,
}

impl PartialEq for MjModelLayout {
    /// `signature` takes no part: only the compiler writes it, so `mj_loadModel` leaves it zero
    /// and a test would refuse a model against its own saved copy.
    fn eq(&self, other: &Self) -> bool {
            self.nexclude == other.nexclude && self.nmat == other.nmat && self.npair == other.npair && self.nskin == other.nskin &&
            self.nkey == other.nkey && self.nmocap == other.nmocap && self.nuserdata == other.nuserdata && self.nhistory == other.nhistory &&
            self.nbvh == other.nbvh && self.nbvhdynamic == other.nbvhdynamic && self.nflexedge == other.nflexedge && self.nflexstiffness == other.nflexstiffness &&
            self.nJmom == other.nJmom && self.nJfe == other.nJfe && self.nJfv == other.nJfv && self.nC == other.nC &&
            self.nD == other.nD && self.ntree == other.ntree && self.narena == other.narena && self.nmeshgraph == other.nmeshgraph &&
            self.nuser_body == other.nuser_body && self.nuser_jnt == other.nuser_jnt && self.nuser_geom == other.nuser_geom && self.nuser_site == other.nuser_site &&
            self.nuser_cam == other.nuser_cam && self.nuser_tendon == other.nuser_tendon && self.nuser_actuator == other.nuser_actuator && self.nuser_sensor == other.nuser_sensor &&
            self.split == other.split
    }
}

impl MjModelLayout {
    /// Returns the compilation signature of the model this layout came from.
    pub(crate) fn signature(&self) -> u64 {
        self.signature
    }

    /// Returns the mesh, texture and heightfield count tables.
    fn asset_split(&self) -> &[Box<[u8]>; ASSET_SPLIT_TABLES] {
        &self.split.assets
    }
}

impl From<&MjModel> for MjModelLayout {
    fn from(model: &MjModel) -> Self {
        let m = model.ffi();
        Self {
            signature: m.signature,
            nexclude: m.nexclude, nmat: m.nmat, npair: m.npair, nskin: m.nskin, nkey: m.nkey,
            nmocap: m.nmocap, nuserdata: m.nuserdata, nhistory: m.nhistory, nbvh: m.nbvh,
            nbvhdynamic: m.nbvhdynamic, nflexedge: m.nflexedge, nflexstiffness: m.nflexstiffness,
            nJmom: m.nJmom, nJfe: m.nJfe, nJfv: m.nJfv, nC: m.nC, nD: m.nD, ntree: m.ntree,
            narena: m.narena,
            nmeshgraph: m.nmeshgraph,
            nuser_body: m.nuser_body, nuser_jnt: m.nuser_jnt, nuser_geom: m.nuser_geom, nuser_site: m.nuser_site,
            nuser_cam: m.nuser_cam, nuser_tendon: m.nuser_tendon, nuser_actuator: m.nuser_actuator,
            nuser_sensor: m.nuser_sensor,
            split: model.split_tables(),
        }
    }
}


/// Count tables of an [`MjModel`], one owned table per entry and as raw bytes, so that a
/// comparison tests the length of each table on its own and then its content.
///
/// One flat buffer would test the sum of the lengths instead, which leaves the element count of a
/// single table free.
#[derive(Clone, PartialEq, Eq)]
pub(crate) struct MjSplitTables {
    assets: [Box<[u8]>; ASSET_SPLIT_TABLES],
    elements: [Box<[u8]>; ELEMENT_SPLIT_TABLES],
}

impl Debug for MjSplitTables {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let assets = self.assets.each_ref().map(|table| table.len());
        let elements = self.elements.each_ref().map(|table| table.len());
        f.debug_struct("MjSplitTables")
            .field("assets", &assets)
            .field("elements", &elements)
            .finish_non_exhaustive()
    }
}


/// A Rust-safe wrapper around mjModel.
/// Automatically clean after itself on destruction.
#[derive(Debug)]
pub struct MjModel {
    ptr: NonNull<mjModel>,
    /// Memory layout for compatibility checks.
    layout: OnceLock<Arc<MjModelLayout>>,
}

// SAFETY: MjModel owns its mjModel heap allocation exclusively. The data is not shared
// outside of Rust, except in the C++ code which is synchronized via wrapper APIs.
unsafe impl Send for MjModel {}
unsafe impl Sync for MjModel {}


impl MjModel {
    /// Loads the model from an XML file. To load from a virtual file system, use [`MjModel::from_xml_vfs`].
    /// Wraps [`mj_loadXML`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::LoadFailed`] if MuJoCo fails to load the model.
    /// # Panics
    /// - when the `path` contains '\0'.
    /// - when the linked MuJoCo version does not match the expected from MuJoCo-rs.
    pub fn from_xml<T: AsRef<Path>>(path: T) -> Result<Self, MjModelError> {
        Self::from_xml_file(path, None)
    }

    /// Loads the model from an XML file, located in a virtual file system (`vfs`)
    /// Wraps [`mj_loadXML`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::LoadFailed`] if MuJoCo fails to load the model.
    /// # Panics
    /// - when the `path` contains '\0'.
    /// - when the linked MuJoCo version does not match the expected from MuJoCo-rs.
    pub fn from_xml_vfs<T: AsRef<Path>>(path: T, vfs: &MjVfs) -> Result<Self, MjModelError> {
        Self::from_xml_file(path, Some(vfs))
    }

    fn from_xml_file<T: AsRef<Path>>(path: T, vfs: Option<&MjVfs>) -> Result<Self, MjModelError> {
        assert_mujoco_version();

        let mut error_buffer = [0; ERROR_BUF_LEN];
        let path_str = path.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let path = CString::new(path_str).unwrap();
        let raw_ptr = unsafe { mj_loadXML(
            path.as_ptr(), vfs.map_or(ptr::null(), |v| v.ffi()),
            error_buffer.as_mut_ptr(), error_buffer.len() as c_int
        ) };

        Self::check_raw_model(raw_ptr, &error_buffer)
            .inspect(|_| debug!("loaded the model from \"{path_str}\""))
    }

    /// Loads the model from an XML string.
    /// Wraps [`mj_loadXML`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// - [`MjModelError::VfsError`] if the internal VFS operation fails.
    /// - [`MjModelError::LoadFailed`] if MuJoCo fails to load the model.
    /// # Panics
    /// Panics if the linked MuJoCo version does not match the version expected by mujoco-rs.
    pub fn from_xml_string(data: &str) -> Result<Self, MjModelError> {
        assert_mujoco_version();

        let mut vfs = MjVfs::new();
        let filename = "model.xml";

        // Add the file into a virtual file system
        vfs.add_from_buffer(filename, data.as_bytes())?;

        let mut error_buffer = [0; ERROR_BUF_LEN];
        let filename_c = CString::new(filename).unwrap();
        let raw_ptr = unsafe { mj_loadXML(
            filename_c.as_ptr(), vfs.ffi(),
            error_buffer.as_mut_ptr(), error_buffer.len() as c_int
        ) };

        Self::check_raw_model(raw_ptr, &error_buffer)
    }

    /// Loads the model from MJB raw data.
    /// Wraps [`mj_loadModelBuffer`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// Returns [`MjModelError::LoadFailed`] if MuJoCo fails to parse the MJB buffer.
    /// # Panics
    /// When the linked MuJoCo version does not match the expected from MuJoCo-rs, or when `data`
    /// is longer than [`i32::MAX`] bytes.
    pub fn from_buffer(data: &[u8]) -> Result<Self, MjModelError> {
        assert_mujoco_version();
        unsafe {
            Self::from_raw(mj_loadModelBuffer(data.as_ptr() as *const c_void, checked_c_len(data.len())))
        }
    }

    /// Loads the model from a binary (MJB) file. To load from a virtual file system, use
    /// [`MjModel::from_mjb_vfs`].
    /// Wraps [`mj_loadModel`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::LoadFailed`] if MuJoCo fails to load the model.
    /// # Panics
    /// - when the `path` contains '\0'.
    /// - when the linked MuJoCo version does not match the expected from MuJoCo-rs.
    pub fn from_mjb<T: AsRef<Path>>(path: T) -> Result<Self, MjModelError> {
        Self::from_mjb_file(path, None)
    }

    /// Loads the model from a binary (MJB) file, located in a virtual file system (`vfs`).
    /// Wraps [`mj_loadModel`].
    /// # Returns
    /// On success, returns [`Ok`] variant containing the loaded [`MjModel`].
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::LoadFailed`] if MuJoCo fails to load the model.
    /// # Panics
    /// - when the `path` contains '\0'.
    /// - when the linked MuJoCo version does not match the expected from MuJoCo-rs.
    pub fn from_mjb_vfs<T: AsRef<Path>>(path: T, vfs: &MjVfs) -> Result<Self, MjModelError> {
        Self::from_mjb_file(path, Some(vfs))
    }

    fn from_mjb_file<T: AsRef<Path>>(path: T, vfs: Option<&MjVfs>) -> Result<Self, MjModelError> {
        assert_mujoco_version();

        let path_str = path.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let path = CString::new(path_str).unwrap();
        let raw_ptr = unsafe { mj_loadModel(
            path.as_ptr(), vfs.map_or(ptr::null(), |v| v.ffi())
        ) };

        Self::from_raw(raw_ptr)
            .inspect(|_| debug!("loaded the model from \"{path_str}\""))
    }

    /// Creates a [`MjModel`] from a raw pointer.
    pub(crate) fn from_raw(ptr: *mut mjModel) -> Result<Self, MjModelError> {
        Self::check_raw_model(ptr, &[0])
    }

    /// Saves the last loaded XML to `filename`.
    /// Wraps [`mj_saveLastXML`].
    /// # Returns
    /// `Ok(())` on success.
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::SaveFailed`] with MuJoCo's error message if saving fails.
    /// # Panics
    /// When the path contains '\0' characters, a panic occurs.
    pub fn save_last_xml<T: AsRef<Path>>(&self, filename: T) -> Result<(), MjModelError> {
        let path_str = filename.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let mut error = [0; ERROR_BUF_LEN];
        let cstring = CString::new(path_str).unwrap();
        let result = unsafe { mj_saveLastXML(
            cstring.as_ptr(), self.ffi(),
            error.as_mut_ptr(), error.len() as i32
        ) };
        match result {
            1 => {
                debug!("saved the last loaded XML to \"{path_str}\"");
                Ok(())
            },
            _ => {
                // SAFETY: error is zero-initialised and MuJoCo NUL-terminates the message it
                // writes into it; the resulting CStr borrows the stack buffer and is consumed
                // before the buffer goes out of scope.
                let cstr_error = unsafe { CStr::from_ptr(error.as_ptr()) }
                    .to_string_lossy()
                    .into_owned();
                Err(MjModelError::SaveFailed(cstr_error))
            },
        }
    }

    /// Encode [`MjModel`] to `filepath` using an encoder registered for encoding `content_type`.
    /// When the `filepath`'s extension is '.xml', '.mjb' or `.txt`, the MuJoCo's internal
    /// XML, MJB and TXT encoders will be used, respectively. Similarly, the MuJoCo's internal
    /// encoders will be used when `content_type` is 'text/xml' or 'text/plain'.
    /// The XML encoder writes the spec of the last [`MjModel::from_xml`] (or `_vfs`, `_string`)
    /// load and fails when there is none.
    /// 
    /// This is a wrapper for [`mj_encode`].
    /// 
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// - [`MjModelError::SaveFailed`] with MuJoCo's error message if encoding fails.
    /// 
    /// # Panics
    /// When `filepath` is empty, or when `filepath` or `content_type` contain interior `\0`
    /// characters. MuJoCo aborts the process when the MJB or TXT encoder cannot write `filepath`.
    /// 
    /// # Note
    /// The MJB and TXT encoders report the size of whatever sits at `filepath` instead of the
    /// bytes they wrote, thus a refused write on an existing file returns `Ok(())` and leaves the
    /// stale file in place.
    pub fn encode(&self, filepath: impl AsRef<Path>, content_type: &str) -> Result<(), MjModelError> {
        self.encode_impl(filepath, content_type, None)
    }

    /// Same as [`MjModel::encode`] except data (assets) are taken from `vfs`.
    /// 
    /// # Errors
    /// The same as [`MjModel::encode`].
    /// 
    /// # Panics
    /// The same as [`MjModel::encode`].
    pub fn encode_with_vfs(&self, filepath: impl AsRef<Path>, content_type: &str, vfs: &MjVfs) -> Result<(), MjModelError> {
        self.encode_impl(filepath, content_type, Some(vfs))
    }

    /// Implementation of the wrapper for [`mj_encode`].
    fn encode_impl(
        &self,
        filepath: impl AsRef<Path>, content_type: &str,
        maybe_vfs: Option<&MjVfs>
    ) -> Result<(), MjModelError> {
        let filepath = filepath.as_ref().to_str().ok_or(MjModelError::InvalidUtf8Path)?;
        encode(None, Some(self), filepath, content_type, maybe_vfs).map_err(MjModelError::SaveFailed)
    }

    /// Creates a new [`MjData`] instance linked to this model.
    ///
    /// # Panics
    /// Panics if MuJoCo fails to allocate the data structure.
    /// Use [`MjModel::try_make_data`] for a fallible alternative.
    pub fn make_data(&self) -> MjData<&Self> {
        MjData::new(self)
    }

    /// Fallible version of [`MjModel::make_data`].
    ///
    /// # Errors
    /// Returns [`MjDataError::AllocationFailed`] if MuJoCo fails to allocate
    /// the data structure.
    pub fn try_make_data(&self) -> Result<MjData<&Self>, MjDataError> {
        MjData::try_new(self)
    }

    /// Wraps a raw model pointer returned by MuJoCo load functions.
    /// Returns an error with the C error-buffer message if the pointer is null.
    fn check_raw_model(ptr_model: *mut mjModel, error_buffer: &[c_char]) -> Result<Self, MjModelError> {
        match NonNull::new(ptr_model) {
            Some(nn) => Ok(Self { ptr: nn, layout: OnceLock::new() }),
            None => {
                // SAFETY: error_buffer is zero-initialised and MuJoCo always
                // NUL-terminates the message it writes into it.
                let message = unsafe { CStr::from_ptr(error_buffer.as_ptr()) }
                    .to_string_lossy()
                    .into_owned();
                Err(MjModelError::LoadFailed(message))
            }
        }
    }

    info_method! { Model, actuator,
        [trntype: 1, dyntype: 1, gaintype: 1, biastype: 1, ctrladr: 1, ctrlnum: 1, ctrlspec: 1,
        outadr: 1, outnum: 1, trnid: 2, actadr: 1, actnum: 1,
        group: 1, history: 2, historyadr: 1, delay: 1, forcelimited: 1, actlimited: 1, dynprm: mjNDYN as usize, gainprm: mjNGAIN as usize, biasprm: mjNBIAS as usize,
        actearly: 1, forcerange: 2, actrange: 2, damping: 1,
        dampingpoly: mjNPOLY as usize, armature: 1, cranklength: 1, plugin: 1],
        [user: nuser_actuator],
        [ctrllimited: nu, ctrlrange: nu * 2, gear: nout * 6, acc0: nout, length0: nout, lengthrange: nout * 2]
    }

    info_method! { Model, body,
        [parentid: 1, rootid: 1, weldid: 1, mocapid: 1, jntnum: 1, jntadr: 1,
        dofnum: 1, dofadr: 1, treeid: 1, geomnum: 1, geomadr: 1, simple: 1,
        sameframe: 1, pos: 3, quat: 4, ipos: 3, iquat: 4, mass: 1, subtreemass: 1,
        inertia: 3, invweight0: 2, gravcomp: 1, margin: 1, plugin: 1,
        contype: 1, conaffinity: 1, bvhadr: 1, bvhnum: 1],
        [user: nuser_body],
        []
    }

    info_method! { Model, camera,
        [mode: 1, bodyid: 1, targetbodyid: 1,
        pos: 3, quat: 4, poscom0: 3,
        pos0: 3, mat0: 9, projection: 1, fovy: 1,
        ipd: 1, resolution: 2, output: 1, sensorsize: 2, intrinsic: 4],
        [user: nuser_cam],
        []
    }
    
    info_method! { Model, joint,
        [r#type: 1, qposadr: 1, dofadr: 1, group: 1,
        limited: 1, actfrclimited: 1, actgravcomp: 1, solref: mjNREF as usize, solimp: mjNIMP as usize,
        pos: 3, axis: 3, stiffness: 1, stiffnesspoly: mjNPOLY as usize,
        range: 2, actfrcrange: 2, margin: 1, bodyid: 1, actuatorid: 1],
        [user: nuser_jnt],
        [qpos0: nq, qpos_spring: nq, jntid: nv,
        dof_bodyid: nv, parentid: nv, dof_treeid: nv, Madr: nv, simplenum: nv, frictionloss: nv,
        armature: nv, damping: nv, dampingpoly: nv * mjNPOLY as usize, invweight0: nv, M0: nv]
    }


    info_method! { Model, equality,
        [r#type: 1, obj1id: 1,
        obj2id: 1, active0: 1,
        solref: mjNREF as usize, solimp: mjNIMP as usize,
        data: mjNEQDATA as usize, objtype: 1],
        [],
        []
    }

    info_method! { Model, exclude,
        [signature: 1],
        [],
        []
    }

    info_method! { Model, geom,
        [r#type: 1, contype: 1, conaffinity: 1, condim: 1, bodyid: 1, dataid: 1, matid: 1,
        group: 1, priority: 1, plugin: 1, sameframe: 1, solmix: 1, solref: mjNREF as usize, solimp: mjNIMP as usize, size: 3,
        aabb: 6, rbound: 1, pos: 3, quat: 4, friction: 3, margin: 1, gap: 1, surfacevel: 6, adhesion: 1, fluid: mjNFLUID as usize, rgba: 4],
        [user: nuser_geom],
        []
    }

    info_method! { Model, hfield,
        [size: 4,
        nrow: 1,
        ncol: 1,
        adr: 1,
        pathadr: 1],
        [],
        [data: nhfielddata]
    }

    info_method! { Model, light,
        [mode: 1, bodyid: 1, targetbodyid: 1, r#type: 1, texid: 1, castshadow: 1,
        bulbradius: 1, intensity: 1, range: 1,
        active: 1, pos: 3, dir: 3, poscom0: 3, pos0: 3,
        dir0: 3, attenuation: 3, cutoff: 1, softness: 1, exponent: 1, ambient: 3,
        diffuse: 3, specular: 3],
        [],
        []
    }

    info_method! { Model, material,
        [texid: MjtTextureRole::mjNTEXROLE as usize, texuniform: 1,
        texrepeat: 2, emission: 1,
        specular: 1, shininess: 1,
        reflectance: 1, rgba: 4, metallic: 1, roughness: 1],
        [],
        []
    }

    info_method! { Model, mesh,
        [vertadr: 1, vertnum: 1,
        texcoordadr: 1, faceadr: 1,
        facenum: 1, graphadr: 1, extrema: 27,
        normaladr: 1, normalnum: 1, texcoordnum: 1,
        bvhadr: 1, bvhnum: 1, octadr: 1, octnum: 1,
        pathadr: 1, polynum: 1, polyadr: 1,
        scale: 3, pos: 3, quat: 4],
        [],
        []
    }

    info_method! { Model, numeric,
        [adr: 1,
        size: 1],
        [],
        [data: nnumericdata]
    }

    info_method! { Model, pair,
        [dim: 1, geom1: 1, geom2: 1,
        signature: 1, solref: mjNREF as usize, solimp: mjNIMP as usize,
        margin: 1, gap: 1, adhesion: 1, friction: 5, solreffriction: mjNREF as usize],
        [],
        []
    }

    info_method! { Model, sensor,
        [r#type: 1, datatype: 1, needstage: 1,
        objtype: 1, objid: 1, reftype: 1,
        refid: 1, intprm: mjNSENS as usize, dim: 1, adr: 1,
        cutoff: 1, noise: 1, history: 2, historyadr: 1, delay: 1, interval: 2, plugin: 1],
        [user: nuser_sensor],
        []
    }

    info_method! { Model, site,
        [r#type: 1, bodyid: 1, matid: 1,
        group: 1, sameframe: 1, size: 3,
        pos: 3, quat: 4, rgba: 4],
        [user: nuser_site],
        []
    }

    info_method! { Model, skin,
        [matid: 1, group: 1, rgba: 4, inflate: 1,
        vertadr: 1, vertnum: 1, texcoordadr: 1,
        faceadr: 1, facenum: 1, boneadr: 1,
        bonenum: 1, pathadr: 1],
        [],
        []
    }

    info_method! { Model, tendon,
        [adr: 1, num: 1, matid: 1, actuatorid: 1, group: 1, treenum: 1, treeid: 2,
        limited: 1, actfrclimited: 1, width: 1,
        solref_lim: mjNREF as usize, solimp_lim: mjNIMP as usize, solref_fri: mjNREF as usize, solimp_fri: mjNIMP as usize, range: 2, actfrcrange: 2, margin: 1,
        stiffness: 1, stiffnesspoly: mjNPOLY as usize, damping: 1, dampingpoly: mjNPOLY as usize, armature: 1,
        frictionloss: 1, lengthspring: 2, length0: 1, invweight0: 1, J_rownnz: 1, J_rowadr: 1, rgba: 4],
        [user: nuser_tendon],
        [J_colind: nJten]
    }

    info_method! { Model, texture,
        [r#type: 1, colorspace: 1, height: 1,
        width: 1, nchannel: 1,
        adr: 1, pathadr: 1],
        [],
        [data: ntexdata]
    }

    info_method! { Model, tuple,
        [adr: 1,
        size: 1],
        [],
        [objtype: ntupledata,
        objid: ntupledata,
        objprm: ntupledata]
    }

    info_method! { Model, key,
        [time: 1],
        [qpos: nq, qvel: nv,
        act: na, mpos: nmocap*3,
        mquat: nmocap*4, ctrl: nu],
        []
    }

    /// Translates `name` to the correct id. Wrapper around `mj_name2id`.
    /// Returns `None` if the name is not found.
    /// Wraps [`mj_name2id`].
    /// # Panics
    /// When the `name` contains '\0' characters, a panic occurs.
    pub fn name_to_id(&self, type_: MjtObj, name: &str) -> Option<usize> {
        let c_string = CString::new(name).unwrap();
        let id = unsafe {
            mj_name2id(self.ffi(), type_ as i32, c_string.as_ptr())
        };
        if id == -1 { None } else { Some(id as usize) }
    }

    /* Partially auto-generated */

    /// Fallible version of [`Clone::clone`].
    ///
    /// Wraps [`mj_copyModel`].
    /// # Note
    /// MuJoCo ends the process when the allocation fails, so this never returns `Err`.
    ///
    /// # Errors
    /// Returns [`MjModelError::AllocationFailed`] if MuJoCo returns a null model.
    #[deprecated(
        since = "6.0.0",
        note = "always returns Ok; use `clone`"
    )]
    pub fn try_clone(&self) -> Result<MjModel, MjModelError> {
        let ptr = unsafe { mj_copyModel(ptr::null_mut(), self.ffi()) };
        NonNull::new(ptr)
            // The copy holds the same sizes and the same tables, so it reuses the snapshot.
            .map(|ptr| MjModel { ptr, layout: self.layout.clone() })
            .ok_or(MjModelError::AllocationFailed)
    }

    /// Save model to binary MJB file.
    ///
    /// Wraps [`mj_saveModel`].
    /// # Returns
    /// `Ok(())` if the path is valid UTF-8 and contains no interior `\0` characters.
    /// **Note:** the underlying C function `mj_saveModel` returns `void`, so file I/O
    /// errors (e.g. permission denied, disk full) are not detectable; `Ok(())` does
    /// **not** guarantee the file was written.
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// # Panics
    /// When the filename contains '\0' characters, a panic occurs.
    pub fn save_to_file<T: AsRef<Path>>(&self, filename: T) -> Result<(), MjModelError> {
        let path_str = filename.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let c_filename = CString::new(path_str).unwrap();
        unsafe { mj_saveModel(
            self.ffi(), c_filename.as_ptr(),
            ptr::null_mut(), 0
        ) };
        debug!("saved the model to \"{path_str}\"");
        Ok(())
    }

    /// Save model to memory buffer.
    /// Wraps [`mj_saveModel`].
    /// # Returns
    /// `Ok(())` on success.
    /// # Errors
    /// - [`MjModelError::BufferTooSmall`] if the buffer is smaller than [`size()`](Self::size).
    pub fn save_to_buffer(&self, buffer: &mut [u8]) -> Result<(), MjModelError> {
        let needed = self.size();
        if buffer.len() < needed {
            return Err(MjModelError::BufferTooSmall {
                needed,
                available: buffer.len(),
            });
        }
        unsafe { mj_saveModel(
            self.ffi(), ptr::null(),
            buffer.as_mut_ptr() as *mut c_void, buffer.len() as i32
        ) };
        Ok(())
    }

    /// Return size of buffer needed to hold model.
    /// Wraps [`mj_sizeModel`].
    pub fn size(&self) -> usize {
        unsafe { mj_sizeModel(self.ffi()) as usize }
    }

    /// Print mjModel to text file, specifying format.
    /// float_format must be a valid printf-style format string for a single float value.
    ///
    /// Wraps [`mj_printFormattedModel`].
    /// # Returns
    /// `Ok(())` if the path and format string are valid UTF-8 and contain no interior `\0`
    /// characters. **Note:** the underlying C function `mj_printFormattedModel` returns `void`,
    /// so file I/O errors are not detectable; `Ok(())` does **not** guarantee the file was written.
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// # Panics
    /// When either string contains '\0' characters, a panic occurs.
    pub fn print_formatted<T: AsRef<Path>>(&self, filename: T, float_format: &str) -> Result<(), MjModelError> {
        let path_str = filename.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let c_filename = CString::new(path_str).unwrap();
        let c_float_format = CString::new(float_format).unwrap();
        unsafe { mj_printFormattedModel(self.ffi(), c_filename.as_ptr(), c_float_format.as_ptr()) }
        Ok(())
    }

    /// Print model to text file.
    ///
    /// Wraps [`mj_printModel`].
    /// # Returns
    /// `Ok(())` if the path is valid UTF-8 and contains no interior `\0` characters.
    /// **Note:** the underlying C function `mj_printModel` returns `void`, so file I/O
    /// errors are not detectable; `Ok(())` does **not** guarantee the file was written.
    /// # Errors
    /// - [`MjModelError::InvalidUtf8Path`] if the path contains invalid UTF-8.
    /// # Panics
    /// When the filename contains '\0' characters, a panic occurs.
    pub fn print<T: AsRef<Path>>(&self, filename: T) -> Result<(), MjModelError> {
        let path_str = filename.as_ref().to_str()
            .ok_or(MjModelError::InvalidUtf8Path)?;
        let c_filename = CString::new(path_str).unwrap();
        unsafe { mj_printModel(self.ffi(), c_filename.as_ptr()) }
        Ok(())
    }

    /// Return size of state specification. The bits of the integer spec correspond to element fields of [`MjtState`](crate::wrappers::mj_data::MjtState).
    /// Wraps [`mj_stateSize`].
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when `spec` is not below `1 << mjNSTATE`.
    pub fn state_size(&self, spec: u32) -> usize {
        unsafe { mj_stateSize(self.ffi(), spec as i32) as usize }
    }

    /// Extract the subset of components specified by `dst_spec` from a state `src`
    /// previously obtained via [`MjData::read_state_into`] or [`MjData::state`]
    /// with components specified by `src_spec`.
    ///
    /// Wraps [`mj_extractState`].
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when `src_spec` is not below
    /// `1 << mjNSTATE`.
    ///
    /// # Panics
    /// - When `src.len()` does not equal the size required by `src_spec`.
    /// - When `dst_spec` is not a subset of `src_spec`.
    ///
    /// Use [`MjModel::try_extract_state`] for a fallible alternative.
    pub fn extract_state(&self, src: &[MjtNum], src_spec: u32, dst_spec: u32) -> Box<[MjtNum]> {
        self.try_extract_state(src, src_spec, dst_spec).unwrap()
    }

    /// Fallible version of [`MjModel::extract_state`].
    ///
    /// Wraps [`mj_extractState`].
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when `src_spec` is not below
    /// `1 << mjNSTATE`.
    /// # Returns
    /// On success, returns [`Ok`] variant containing the extracted state.
    /// # Errors
    /// - When `src.len()` does not equal the size required by `src_spec`, [`MjModelError::StateSliceLengthMismatch`] is returned.
    /// - When `dst_spec` is not a subset of `src_spec`, [`MjModelError::SpecNotSubset`] is returned.
    pub fn try_extract_state(&self, src: &[MjtNum], src_spec: u32, dst_spec: u32) -> Result<Box<[MjtNum]>, MjModelError> {
        let expected = self.state_size(src_spec);
        if src.len() != expected {
            return Err(MjModelError::StateSliceLengthMismatch { expected, got: src.len() });
        }

        if (dst_spec & src_spec) != dst_spec {
            return Err(MjModelError::SpecNotSubset);
        }

        let required_size = self.state_size(dst_spec);
        let mut dst = Vec::with_capacity(required_size);

        // SAFETY: all pointer arguments are valid for the duration of this call. mj_extractState
        // writes exactly `required_size` elements into dst; set_len then exposes only those
        // initialized elements.
        unsafe {
            mj_extractState(
                self.ffi(),
                src.as_ptr(), src_spec as i32,
                dst.as_mut_ptr(), dst_spec as i32
            );

            dst.set_len(required_size);
            Ok(dst.into_boxed_slice())
        }
    }

    /// Extract into dst the subset of components specified by `dst_spec` from a state `src`
    /// previously obtained via [`MjData::read_state_into`] or [`MjData::state`]
    /// with components specified by `src_spec`.
    ///
    /// Wraps [`mj_extractState`].
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when `src_spec` is not below
    /// `1 << mjNSTATE`.
    ///
    /// # Panics
    /// - When `src.len()` does not equal the size required by `src_spec`.
    /// - When `dst_spec` is not a subset of `src_spec`.
    /// - When `dst` is too small to hold the requested components.
    ///
    /// Use [`MjModel::try_extract_state_into`] for a fallible alternative.
    pub fn extract_state_into(&self, src: &[MjtNum], src_spec: u32, dst: &mut [MjtNum], dst_spec: u32) -> usize {
        self.try_extract_state_into(src, src_spec, dst, dst_spec).unwrap()
    }

    /// Fallible version of [`MjModel::extract_state_into`].
    ///
    /// Wraps [`mj_extractState`].
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when `src_spec` is not below
    /// `1 << mjNSTATE`.
    /// # Returns
    /// On success, returns [`Ok`] variant containing the number of elements written to `dst`.
    /// # Errors
    /// - When `src.len()` does not equal the size required by `src_spec`, [`MjModelError::StateSliceLengthMismatch`] is returned.
    /// - When `dst_spec` is not a subset of `src_spec`, [`MjModelError::SpecNotSubset`] is returned.
    /// - When `dst` is too small to hold the requested components, [`MjModelError::BufferTooSmall`] is returned.
    pub fn try_extract_state_into(&self, src: &[MjtNum], src_spec: u32, dst: &mut [MjtNum], dst_spec: u32) -> Result<usize, MjModelError> {
        let expected = self.state_size(src_spec);
        if src.len() != expected {
            return Err(MjModelError::StateSliceLengthMismatch { expected, got: src.len() });
        }

        if (dst_spec & src_spec) != dst_spec {
            return Err(MjModelError::SpecNotSubset);
        }

        let required_size = self.state_size(dst_spec);
        let available_size = dst.len();

        if available_size < required_size  {
            return Err(MjModelError::BufferTooSmall { needed: required_size, available: available_size });
        }

        unsafe {
            mj_extractState(
                self.ffi(),
                src.as_ptr(), src_spec as i32,
                dst.as_mut_ptr(), dst_spec as i32
            );
        }

        Ok(required_size)
    }

    /// Compute the velocity that carries `qpos1` to `qpos2` in `dt`.
    ///
    /// Wraps [`mj_differentiatePos`].
    /// 
    /// # Panics
    /// Panics when `qpos1` or `qpos2` does not hold [`MjModel::nq`] elements.
    /// Use [`MjModel::try_differentiate_pos`] for a fallible alternative.
    pub fn differentiate_pos(&self, dt: MjtNum, qpos1: &[MjtNum], qpos2: &[MjtNum]) -> Box<[MjtNum]> {
        self.try_differentiate_pos(dt, qpos1, qpos2).unwrap()
    }

    /// Fallible version of [`MjModel::differentiate_pos`].
    ///
    /// Wraps [`mj_differentiatePos`].
    /// 
    /// # Returns
    /// On success, returns [`Ok`] variant containing the velocity, of [`MjModel::nv`] elements.
    /// 
    /// # Errors
    /// - When `qpos1` or `qpos2` does not hold [`MjModel::nq`] elements,
    ///   [`MjModelError::LengthMismatch`] is returned.
    pub fn try_differentiate_pos(&self, dt: MjtNum, qpos1: &[MjtNum], qpos2: &[MjtNum]) -> Result<Box<[MjtNum]>, MjModelError> {
        let mut qvel = vec![0 as MjtNum; self.ffi().nv as usize];
        self.try_differentiate_pos_into(dt, qpos1, qpos2, &mut qvel)?;
        Ok(qvel.into_boxed_slice())
    }

    /// Same as [`MjModel::differentiate_pos`], except it writes the [`MjModel::nv`] elements into
    /// `qvel`. Elements of `qvel` above index `nv` keep their previous values.
    ///
    /// Wraps [`mj_differentiatePos`].
    /// 
    /// # Panics
    /// - When `qpos1` or `qpos2` does not hold [`MjModel::nq`] elements.
    /// - When `qvel` holds fewer than [`MjModel::nv`] elements.
    /// 
    /// Use [`MjModel::try_differentiate_pos_into`] for a fallible alternative.
    pub fn differentiate_pos_into(&self, dt: MjtNum, qpos1: &[MjtNum], qpos2: &[MjtNum], qvel: &mut [MjtNum]) {
        self.try_differentiate_pos_into(dt, qpos1, qpos2, qvel).unwrap()
    }

    /// Fallible version of [`MjModel::differentiate_pos_into`].
    ///
    /// Wraps [`mj_differentiatePos`].
    /// 
    /// # Errors
    /// - When `qpos1` or `qpos2` does not hold [`MjModel::nq`] elements,
    ///   [`MjModelError::LengthMismatch`] is returned.
    /// - When `qvel` holds fewer than [`MjModel::nv`] elements,
    ///   [`MjModelError::BufferTooSmall`] is returned.
    pub fn try_differentiate_pos_into(&self, dt: MjtNum, qpos1: &[MjtNum], qpos2: &[MjtNum], qvel: &mut [MjtNum]) -> Result<(), MjModelError> {
        let nq = self.ffi().nq as usize;
        if qpos1.len() != nq {
            return Err(MjModelError::LengthMismatch { name: "qpos1", expected: nq, got: qpos1.len() });
        }

        if qpos2.len() != nq {
            return Err(MjModelError::LengthMismatch { name: "qpos2", expected: nq, got: qpos2.len() });
        }

        let nv = self.ffi().nv as usize;
        if qvel.len() < nv {
            return Err(MjModelError::BufferTooSmall { needed: nv, available: qvel.len() });
        }

        // SAFETY: all pointers are valid for the duration of this call; qpos1 and qpos2 hold nq
        // elements and qvel holds at least nv elements, as checked above.
        unsafe {
            mj_differentiatePos(
                self.ffi(),
                qvel.as_mut_ptr(), dt,
                qpos1.as_ptr(), qpos2.as_ptr()
            )
        };

        Ok(())
    }

    /// Integrate `qpos` in place with velocity `qvel` and time step `dt`.
    ///
    /// Wraps [`mj_integratePos`].
    /// # Panics
    /// - When `qpos` does not hold [`MjModel::nq`] elements.
    /// - When `qvel` does not hold [`MjModel::nv`] elements.
    pub fn integrate_pos(&self, qpos: &mut [MjtNum], qvel: &[MjtNum], dt: MjtNum) {
        // mj_integratePos reads both vectors by the model layout, without a length of its own.
        assert_eq!(qpos.len(), self.ffi().nq as usize, "qpos must hold nq elements");
        assert_eq!(qvel.len(), self.ffi().nv as usize, "qvel must hold nv elements");

        // SAFETY: both pointers are valid for the duration of this call, with the lengths that the
        // model layout requires, as checked above.
        unsafe { mj_integratePos(self.ffi(), qpos.as_mut_ptr(), qvel.as_ptr(), dt) }
    }

    /// Normalize every ball and free joint quaternion of a `qpos` vector in place.
    ///
    /// Wraps [`mj_normalizeQuat`].
    /// # Panics
    /// Panics when `qpos` does not hold [`MjModel::nq`] elements.
    pub fn normalize_quat(&self, qpos: &mut [MjtNum]) {
        // mj_normalizeQuat reads the vector by the model layout, without a length of its own.
        assert_eq!(qpos.len(), self.ffi().nq as usize, "qpos must hold nq elements");

        // SAFETY: the pointer is valid for the duration of this call, with the length that the
        // model layout requires, as checked above.
        unsafe { mj_normalizeQuat(self.ffi(), qpos.as_mut_ptr()) }
    }

    /// Determine type of friction cone. Returns `true` if pyramidal, `false` if elliptic.
    /// Wraps [`mj_isPyramidal`].
    pub fn is_pyramidal(&self) -> bool {
        unsafe { mj_isPyramidal(self.ffi()) == 1 }
    }

    /// Determine type of constraint Jacobian. Returns `true` if sparse, `false` if dense.
    /// Wraps [`mj_isSparse`].
    pub fn is_sparse(&self) -> bool {
        unsafe { mj_isSparse(self.ffi()) == 1 }
    }

    /// Determine type of solver. Returns `true` for a dual solver: PGS, or any solver with
    /// `noslip_iterations > 0`.
    /// Wraps [`mj_isDual`].
    pub fn is_dual(&self) -> bool {
        unsafe { mj_isDual(self.ffi()) == 1 }
    }

    /// Get name of object with the specified [`MjtObj`] type and id, returns `None` if name not found.
    /// Wraps [`mj_id2name`].
    /// # Panics
    /// Panics if MuJoCo internally returns a C string that is not valid UTF-8.
    pub fn id_to_name(&self, type_: MjtObj, id: usize) -> Option<&str> {
        let ptr = unsafe { mj_id2name(self.ffi(), type_ as i32, id as i32) };
        if ptr.is_null() {
            None
        }
        else {
            // SAFETY: ptr was checked non-null above; MuJoCo NUL-terminates the names blob and it
            // lives as long as the model.
            let cstr = unsafe { CStr::from_ptr(ptr).to_str().unwrap() };
            Some(cstr)
        }
    }

    /// Sum all body masses.
    /// Wraps [`mj_getTotalmass`].
    pub fn totalmass(&self) -> MjtNum {
        unsafe { mj_getTotalmass(self.ffi()) }
    }

    /// Scale body masses and inertias to achieve specified total mass.
    /// Wraps [`mj_setTotalmass`].
    pub fn set_totalmass(&mut self, newmass: MjtNum) {
        unsafe { mj_setTotalmass(self.ffi_mut(), newmass) }
    }

    /// Return the maximum number of contacts that can be generated between two geoms.
    /// 
    /// To pull margin from model, set `has_margin` to [`None`], otherwise pass `true` or `false`
    /// inside [`Some`] (true indicating a present margin). 
    /// 
    /// Wraps [`mj_maxContact`].
    /// # Panics
    /// Panics when either `geom1` or `geom2` are equal or greater than [`MjModel::ngeom`].
    /// Use [`MjModel::try_max_contacts`] for a fallible alternative.
    pub fn max_contacts(&self, geom1: usize, geom2: usize, has_margin: Option<bool>) -> u32 {
        self.try_max_contacts(geom1, geom2, has_margin).unwrap()
    }

    /// Fallible version of [`MjModel::max_contacts`].
    /// Wraps [`mj_maxContact`].
    /// # Errors
    /// Returns [`MjModelError::IndexOutOfBounds`] when either `geom1` or `geom2` are equal or
    /// greater than [`MjModel::ngeom`].
    pub fn try_max_contacts(&self, geom1: usize, geom2: usize, has_margin: Option<bool>) -> Result<u32, MjModelError> {
        let ngeom = self.ngeom() as usize;

        if geom1 >= ngeom {
            return Err(MjModelError::IndexOutOfBounds { id: geom1, len: ngeom });
        }

        if geom2 >= ngeom {
            return Err(MjModelError::IndexOutOfBounds { id: geom2, len: ngeom });
        }

        Ok(unsafe { mj_maxContact(
            self.ffi(),
            geom1 as i32, geom2 as i32,
            // if Some(...), pass 0 or 1, otherwise pull from model (-1)
            has_margin.map(|m| m as i32).unwrap_or(-1)
        ) as u32 })
    }

    /// Returns the name that the type of actuator `id` gives to its control input `input`, an
    /// index into the control block of the actuator. For example, an orientation servo on the
    /// exponential-map chart names its first input `"rx"`.
    /// Wraps [`mj_actuatorInputName`].
    /// # Returns
    /// [`None`] when the actuator type defines no input names, or when `id` or `input` is out of
    /// range.
    /// # Panics
    /// Panics if the reported name is not valid UTF-8.
    pub fn actuator_input_name(&self, id: usize, input: usize) -> Option<&'static str> {
        // SAFETY: id and input are checked inside the function. When c_ptr is not null, it is
        // always an ASCII static C string constant, so the UTF-8 check cannot fail.
        unsafe {
            let c_ptr = mj_actuatorInputName(self.ffi(), id as i32, input as i32);
            (!c_ptr.is_null()).then(|| CStr::from_ptr(c_ptr).to_str().unwrap())
        }
    }

    /* FFI */
    /// Returns a reference to the wrapped FFI struct.
    pub fn ffi(&self) -> &mjModel {
        // SAFETY: self.ptr is a valid non-null mjModel pointer for the lifetime of self
        // (struct invariant).
        unsafe { self.ptr.as_ref() }
    }

    /// Returns a mutable reference to the wrapped FFI struct.
    ///
    /// # Safety
    /// The caller must ensure that any modifications to the underlying struct preserve
    /// the invariants that MuJoCo expects (e.g. do not corrupt computed fields or
    /// break index relationships). Violating these invariants can cause undefined behavior.
    /// A write that changes a size or an address table also leaves the cached layout stale, so
    /// [`MjModel::is_compatible_with_model`] then answers for the model as it was loaded.
    pub unsafe fn ffi_mut(&mut self) -> &mut mjModel {
        unsafe { self.ptr.as_mut() }
    }

    /// Returns a direct mutable pointer to the underlying C model struct.
    /// Only for internal use by viewer code that passes the pointer to C++ FFI.
    #[cfg(feature = "cpp-viewer")]
    pub(crate) fn as_raw_ptr(&self) -> *mut mjModel {
        self.ptr.as_ptr()
    }
}


/// Public attribute methods.
impl MjModel {
    /// Compilation signature.
    pub fn signature(&self) -> u64 {
        self.ffi().signature
    }

    /// Reports whether `other` is memory-compatible with this model.
    pub fn is_compatible_with_model(&self, other: &MjModel) -> bool {
        self.layout() == other.layout()
    }

    /// Reports whether `other`'s assets are memory-compatible with this model's.
    pub fn is_asset_compatible_with_model(&self, other: &MjModel) -> bool {
        self.layout().nmeshgraph == other.layout().nmeshgraph
            && self.layout().asset_split() == other.layout().asset_split()
    }

    /// Returns the per-sensor, per-numeric, per-tuple, per-actuator, per-tendon, per-flex and
    /// plugin count tables, as raw bytes in a fixed order.
    fn element_split_tables(&self) -> [&[u8]; ELEMENT_SPLIT_TABLES] {
        [
            must_cast_slice(self.sensor_dim()),         must_cast_slice(self.numeric_size()),
            must_cast_slice(self.tuple_size()),         must_cast_slice(self.actuator_actnum()),
            must_cast_slice(self.actuator_ctrlnum()),   must_cast_slice(self.actuator_outnum()),
            // A tendon Info caches its Jacobian row, which ten_J_rownnz sizes inside nJten.
            must_cast_slice(self.ten_j_rownnz()),
            // An mjData contact holds a flex element index that C resolves through
            // flex_elemdataadr, and mj_resetData relays a plugin instance to the slot in m->plugin.
            must_cast_slice(self.flex_dim()),           must_cast_slice(self.flex_vertnum()),
            must_cast_slice(self.flex_elemnum()),       must_cast_slice(self.plugin()),
            // plugin_stateadr is the prefix sum of plugin_statenum inside npluginstate.
            must_cast_slice(self.plugin_statenum()),
            // Every per-element type below fixes what a state, a control or an output MEANS. The
            // length of each one also pins the count of the elements it describes.
            must_cast_slice(self.jnt_type()),
            must_cast_slice(self.geom_type()),          must_cast_slice(self.eq_type()),
            must_cast_slice(self.eq_objtype()),         must_cast_slice(self.wrap_type()),
            must_cast_slice(self.actuator_trntype()),   must_cast_slice(self.actuator_dyntype()),
            must_cast_slice(self.actuator_gaintype()),  must_cast_slice(self.actuator_biastype()),
            must_cast_slice(self.sensor_type()),        must_cast_slice(self.sensor_objtype()),
            must_cast_slice(self.sensor_reftype()),     must_cast_slice(self.sensor_datatype()),
            must_cast_slice(self.sensor_needstage()),
            // The kinematic tree, and the body that owns each element. `mjModel` holds the tree as
            // a parent id per body, so the nesting travels as data.
            must_cast_slice(self.body_parentid()),      must_cast_slice(self.jnt_bodyid()),
            must_cast_slice(self.geom_bodyid()),        must_cast_slice(self.site_bodyid()),
            must_cast_slice(self.cam_bodyid()),         must_cast_slice(self.light_bodyid()),
        ]
    }

    /// Returns the per-mesh, per-texture and per-heightfield count tables, plus the texture kinds,
    /// as raw bytes in a fixed order.
    fn asset_split_tables(&self) -> [&[u8]; ASSET_SPLIT_TABLES] {
        [
            must_cast_slice(self.mesh_vertnum()),       must_cast_slice(self.mesh_normalnum()),
            must_cast_slice(self.mesh_texcoordnum()),   must_cast_slice(self.mesh_facenum()),
            // mesh_graphadr travels as an address: its length is the size of the convex hull that
            // qhull builds, and mjModel holds no count for it.
            must_cast_slice(self.mesh_graphadr()),
            must_cast_slice(self.tex_width()),          must_cast_slice(self.tex_height()),
            must_cast_slice(self.tex_nchannel()),
            // A cube texture holds the same bytes as a 2D texture of the same width and height,
            // so the sizes alone leave the kind free. mjr_makeContext records tex_type in
            // mjrContext, and mjr_uploadTexture binds GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP by it.
            must_cast_slice(self.tex_type()),
            must_cast_slice(self.hfield_nrow()),        must_cast_slice(self.hfield_ncol()),
        ]
    }

    /// Copies every asset table and every element table into its own buffer.
    fn split_tables(&self) -> MjSplitTables {
        MjSplitTables {
            assets: self.asset_split_tables().map(Box::from),
            elements: self.element_split_tables().map(Box::from),
        }
    }

    /// Returns the memory layout snapshot of this model.
    pub(crate) fn layout(&self) -> &Arc<MjModelLayout> {
        self.layout.get_or_init(|| Arc::new(MjModelLayout::from(self)))
    }

    getter_setter! {get, [
        [ffi] nq: MjtSize; "number of generalized coordinates = dim(qpos).";
        [ffi] nv: MjtSize; "number of degrees of freedom = dim(qvel).";
        [ffi] nu: MjtSize; "number of scalar controls = dim(ctrl).";
        [ffi] nactuator: MjtSize; "number of actuators.";
        [ffi] nout: MjtSize; "number of force outputs, derived from transmission type.";
        [ffi] na: MjtSize; "number of activation states = dim(act).";
        [ffi] nbody: MjtSize; "number of bodies.";
        [ffi] nbvh: MjtSize; "number of total bounding volumes in all bodies.";
        [ffi] nbvhstatic: MjtSize; "number of static bounding volumes (aabb stored in mjModel).";
        [ffi] nbvhdynamic: MjtSize; "number of dynamic bounding volumes (aabb stored in mjData).";
        [ffi] noct: MjtSize; "number of total octree cells in all meshes.";
        [ffi] njnt: MjtSize; "number of joints.";
        [ffi] ntree: MjtSize; "number of kinematic trees under world body.";
        [ffi] nM: MjtSize; "number of non-zeros in sparse inertia matrix.";
        [ffi] nB: MjtSize; "number of non-zeros in sparse body-dof matrix.";
        [ffi] nC: MjtSize; "number of non-zeros in sparse reduced dof-dof matrix.";
        [ffi] nD: MjtSize; "number of non-zeros in sparse dof-dof matrix.";
        [ffi] ngeom: MjtSize; "number of geoms.";
        [ffi] nsite: MjtSize; "number of sites.";
        [ffi] ncam: MjtSize; "number of cameras.";
        [ffi] nlight: MjtSize; "number of lights.";
        [ffi] nflex: MjtSize; "number of flexes.";
        [ffi] nflexnode: MjtSize; "number of dofs in all flexes.";
        [ffi] nflexvert: MjtSize; "number of vertices in all flexes.";
        [ffi] nflexedge: MjtSize; "number of edges in all flexes.";
        [ffi] nflexelem: MjtSize; "number of elements in all flexes.";
        [ffi] nflexelemdata: MjtSize; "number of element vertex ids in all flexes.";
        [ffi] nflexstiffness: MjtSize; "number of stiffness parameters in all flexes.";
        [ffi] nflexbending: MjtSize; "number of bending parameters in all flexes";
        [ffi] nefm0dof: MjtSize; "number of dofs covered by the constant metric factor.";
        [ffi] nefm0L: MjtSize; "number of non-zeros in the constant metric factor.";
        [ffi] nflexelemedge: MjtSize; "number of element edge ids in all flexes.";
        [ffi] nflexshelldata: MjtSize; "number of shell fragment vertex ids in all flexes.";
        [ffi] nflexevpair: MjtSize; "number of element-vertex pairs in all flexes.";
        [ffi] nflextexcoord: MjtSize; "number of vertices with texture coordinates.";
        [ffi] nJfe: MjtSize; "number of non-zeros in sparse flexedge Jacobian matrix.";
        [ffi] nJfv: MjtSize; "number of non-zeros in sparse flexvert Jacobian matrix.";
        [ffi] nmesh: MjtSize; "number of meshes.";
        [ffi] nmeshvert: MjtSize; "number of vertices in all meshes.";
        [ffi] nmeshnormal: MjtSize; "number of normals in all meshes.";
        [ffi] nmeshtexcoord: MjtSize; "number of texcoords in all meshes.";
        [ffi] nmeshface: MjtSize; "number of triangular faces in all meshes.";
        [ffi] nmeshgraph: MjtSize; "number of ints in mesh auxiliary data.";
        [ffi] nmeshpoly: MjtSize; "number of polygons in all meshes.";
        [ffi] nmeshpolyvert: MjtSize; "number of vertices in all polygons.";
        [ffi] nmeshpolymap: MjtSize; "number of polygons in vertex map.";
        [ffi] nskin: MjtSize; "number of skins.";
        [ffi] nskinvert: MjtSize; "number of vertices in all skins.";
        [ffi] nskintexvert: MjtSize; "number of vertices with texcoords in all skins.";
        [ffi] nskinface: MjtSize; "number of triangular faces in all skins.";
        [ffi] nskinbone: MjtSize; "number of bones in all skins.";
        [ffi] nskinbonevert: MjtSize; "number of vertices in all skin bones.";
        [ffi] nhfield: MjtSize; "number of heightfields.";
        [ffi] nhfielddata: MjtSize; "number of data points in all heightfields.";
        [ffi] ntex: MjtSize; "number of textures.";
        [ffi] ntexdata: MjtSize; "number of bytes in texture rgb data.";
        [ffi] nmat: MjtSize; "number of materials.";
        [ffi] npair: MjtSize; "number of predefined geom pairs.";
        [ffi] nexclude: MjtSize; "number of excluded geom pairs.";
        [ffi] neq: MjtSize; "number of equality constraints.";
        [ffi] ntendon: MjtSize; "number of tendons.";
        [ffi] nJten: MjtSize; "number of non-zeros in sparse tendon Jacobian matrix.";
        [ffi] nwrap: MjtSize; "number of wrap objects in all tendon paths.";
        [ffi] nsensor: MjtSize; "number of sensors.";
        [ffi] nnumeric: MjtSize; "number of numeric custom fields.";
        [ffi] nnumericdata: MjtSize; "number of mjtNums in all numeric fields.";
        [ffi] ntext: MjtSize; "number of text custom fields.";
        [ffi] ntextdata: MjtSize; "number of mjtBytes in all text fields.";
        [ffi] ntuple: MjtSize; "number of tuple custom fields.";
        [ffi] ntupledata: MjtSize; "number of objects in all tuple fields.";
        [ffi] nkey: MjtSize; "number of keyframes.";
        [ffi] nmocap: MjtSize; "number of mocap bodies.";
        [ffi] nplugin: MjtSize; "number of plugin instances.";
        [ffi] npluginattr: MjtSize; "number of chars in all plugin config attributes.";
        [ffi] nuser_body: MjtSize; "number of mjtNums in body_user.";
        [ffi] nuser_jnt: MjtSize; "number of mjtNums in jnt_user.";
        [ffi] nuser_geom: MjtSize; "number of mjtNums in geom_user.";
        [ffi] nuser_site: MjtSize; "number of mjtNums in site_user.";
        [ffi] nuser_cam: MjtSize; "number of mjtNums in cam_user.";
        [ffi] nuser_tendon: MjtSize; "number of mjtNums in tendon_user.";
        [ffi] nuser_actuator: MjtSize; "number of mjtNums in actuator_user.";
        [ffi] nuser_sensor: MjtSize; "number of mjtNums in sensor_user.";
        [ffi] nnames: MjtSize; "number of chars in all names.";
        [ffi] npaths: MjtSize; "number of chars in all paths.";
        [ffi] nnames_map: MjtSize; "number of slots in the names hash map.";
        [ffi] nJmom: MjtSize; "number of non-zeros in sparse actuator_moment matrix.";
        [ffi] ngravcomp: MjtSize; "number of bodies with nonzero gravcomp.";
        [ffi] nemax: MjtSize; "number of potential equality-constraint rows.";
        [ffi] njmax: MjtSize; "number of available rows in constraint Jacobian (legacy).";
        [ffi] nconmax: MjtSize; "number of potential contacts in contact list (legacy).";
        [ffi] npolygonmax: MjtSize; "maximum number of vertices in a mesh polygon.";
        [ffi] nmeshdegmax: MjtSize; "maximum number of edges adjacent to a mesh vertex.";
        [ffi] nuserdata: MjtSize; "number of mjtNums reserved for the user.";
        [ffi] nsensordata: MjtSize; "number of mjtNums in sensor data vector.";
        [ffi] npluginstate: MjtSize; "number of mjtNums in plugin state vector.";
        [ffi] nhistory: MjtSize; "number of mjtNums in history buffer.";
        [ffi] narena: MjtSize; "number of bytes in the mjData arena (inclusive of stack).";
        [ffi] nbuffer: MjtSize; "number of bytes in buffer.";
        [ffi] flg_gravcomp: MjtBool; "whether any body has nonzero gravcomp.";
        [ffi] flg_surfacevel: MjtBool; "whether any geom has nonzero surfacevel.";
        [ffi] flg_adhesion: MjtBool; "whether any geom or pair has nonzero adhesion.";
    ]}

    getter_setter! {get, [
        [ffi, ffi_mut] opt: &MjOption; "physics options.";
        [ffi, ffi_mut] vis: &MjVisual; "visualization options.";
        [ffi, ffi_mut] stat: &MjStatistic; "model statistics.";
    ]}
}

/// Array slices.
impl MjModel {
    array_slice_dyn! {
        probe = probe_dynamic_arrays;
        qpos0: &[MjtNum; "qpos values at default pose"; ffi().nq],
        qpos_spring: &[MjtNum; "reference pose for springs"; ffi().nq],
        (mut = unsafe) body_parentid: &[i32; "id of body's parent"; ffi().nbody],
        (mut = unsafe) body_rootid: &[i32; "ancestor that is direct child of world"; ffi().nbody],
        (mut = unsafe) body_weldid: &[i32; "top dof-less ancestor; mocap: own root"; ffi().nbody],
        (mut = unsafe) body_mocapid: &[i32; "id of mocap data; -1: none"; ffi().nbody],
        (mut = unsafe) body_jntnum: &[i32; "number of joints for this body"; ffi().nbody],
        (mut = unsafe) body_jntadr: &[i32; "start addr of joints; -1: no joints"; ffi().nbody],
        (mut = unsafe) body_dofnum: &[i32; "number of motion degrees of freedom"; ffi().nbody],
        (mut = unsafe) body_dofadr: &[i32; "start addr of dofs; -1: no dofs"; ffi().nbody],
        (mut = unsafe) body_treeid: &[i32; "id of body's kinematic tree; -1: static"; ffi().nbody],
        (mut = unsafe) body_geomnum: &[i32; "number of geoms"; ffi().nbody],
        (mut = unsafe) body_geomadr: &[i32; "start addr of geoms; -1: no geoms"; ffi().nbody],
        body_simple: &[MjtByte; "1: diag M; 2: diag M, sliders only"; ffi().nbody],
        body_sameframe: &[MjtSameFrame [force]; "same frame as inertia"; ffi().nbody],
        body_pos: &[[MjtNum; 3] [force]; "position offset rel. to parent body"; ffi().nbody],
        body_quat: &[[MjtNum; 4] [force]; "orientation offset rel. to parent body"; ffi().nbody],
        body_ipos: &[[MjtNum; 3] [force]; "local position of center of mass"; ffi().nbody],
        body_iquat: &[[MjtNum; 4] [force]; "local orientation of inertia ellipsoid"; ffi().nbody],
        body_mass: &[MjtNum; "mass"; ffi().nbody],
        body_subtreemass: &[MjtNum; "mass of subtree starting at this body"; ffi().nbody],
        body_inertia: &[[MjtNum; 3] [force]; "diagonal inertia in ipos/iquat frame"; ffi().nbody],
        body_invweight0: &[[MjtNum; 2] [force]; "mean inv inert in qpos0 (trn, rot)"; ffi().nbody],
        body_gravcomp: &[MjtNum; "antigravity force, units of body weight"; ffi().nbody],
        body_margin: &[MjtNum; "MAX over all geom margins+gaps"; ffi().nbody],
        (mut = unsafe) body_plugin: &[i32; "plugin instance id; -1: not in use"; ffi().nbody],
        body_contype: &[i32; "OR over all geom contypes"; ffi().nbody],
        body_conaffinity: &[i32; "OR over all geom conaffinities"; ffi().nbody],
        (mut = unsafe) body_bvhadr: &[i32; "address of bvh root"; ffi().nbody],
        (mut = unsafe) body_bvhnum: &[i32; "number of bounding volumes"; ffi().nbody],
        bvh_depth: &[i32; "depth in the bounding volume hierarchy"; ffi().nbvh],
        (mut = unsafe) bvh_child: &[[i32; 2] [force]; "left and right children in tree"; ffi().nbvh],
        (mut = unsafe) bvh_nodeid: &[i32; "geom or elem id of node; -1: non-leaf"; ffi().nbvh],
        bvh_aabb: &[[MjtNum; 6] [force]; "local bounding box (center, size)"; ffi().nbvhstatic],
        oct_depth: &[i32; "depth in the octree"; ffi().noct],
        (mut = unsafe) oct_child: &[[i32; 8] [force]; "children of octree node"; ffi().noct],
        oct_aabb: &[[MjtNum; 6] [force]; "octree node bounding box (center, size)"; ffi().noct],
        oct_coeff: &[[MjtNum; 8] [force]; "octree interpolation coefficients"; ffi().noct],
        (mut = unsafe) jnt_type: &[MjtJoint [force]; "type of joint"; ffi().njnt],
        (mut = unsafe) jnt_qposadr: &[i32; "start addr in 'qpos' for joint's data"; ffi().njnt],
        (mut = unsafe) jnt_dofadr: &[i32; "start addr in 'qvel' for joint's data"; ffi().njnt],
        (mut = unsafe) jnt_bodyid: &[i32; "id of joint's body"; ffi().njnt],
        (mut = unsafe) jnt_actuatorid: &[i32; "actuator contributing damping / armature"; ffi().njnt],
        jnt_group: &[i32; "group for visibility"; ffi().njnt],
        jnt_limited: &[MjtBool; "does joint have limits"; ffi().njnt],
        jnt_actfrclimited: &[MjtBool; "does joint have actuator force limits"; ffi().njnt],
        jnt_actgravcomp: &[MjtBool; "is gravcomp force applied via actuators"; ffi().njnt],
        jnt_solref: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference: limit"; ffi().njnt],
        jnt_solimp: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance: limit"; ffi().njnt],
        jnt_pos: &[[MjtNum; 3] [force]; "local anchor position"; ffi().njnt],
        jnt_axis: &[[MjtNum; 3] [force]; "local joint axis"; ffi().njnt],
        jnt_stiffness: &[MjtNum; "linear stiffness coefficient"; ffi().njnt],
        jnt_stiffnesspoly: &[[MjtNum; mjNPOLY as usize] [force]; "high-order stiffness coefficients"; ffi().njnt],
        jnt_range: &[[MjtNum; 2] [force]; "joint limits"; ffi().njnt],
        jnt_actfrcrange: &[[MjtNum; 2] [force]; "range of total actuator force"; ffi().njnt],
        jnt_margin: &[MjtNum; "min distance for limit detection"; ffi().njnt],
        (mut = unsafe) dof_bodyid: &[i32; "id of dof's body"; ffi().nv],
        (mut = unsafe) dof_jntid: &[i32; "id of dof's joint"; ffi().nv],
        (mut = unsafe) dof_parentid: &[i32; "id of dof's parent; -1: none"; ffi().nv],
        (mut = unsafe) dof_treeid: &[i32; "id of dof's kinematic tree"; ffi().nv],
        (mut = unsafe) dof_Madr: &[i32; "dof address in M-diagonal"; ffi().nv],
        dof_simplenum: &[i32; "number of consecutive simple dofs"; ffi().nv],
        dof_solref: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference:frictionloss"; ffi().nv],
        dof_solimp: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance:frictionloss"; ffi().nv],
        dof_frictionloss: &[MjtNum; "dof friction loss"; ffi().nv],
        dof_armature: &[MjtNum; "dof armature inertia/mass"; ffi().nv],
        dof_damping: &[MjtNum; "linear damping coefficient"; ffi().nv],
        dof_dampingpoly: &[[MjtNum; mjNPOLY as usize] [force]; "high-order damping coefficients"; ffi().nv],
        dof_invweight0: &[MjtNum; "diag. inverse inertia in qpos0"; ffi().nv],
        dof_M0: &[MjtNum; "diag. inertia in qpos0"; ffi().nv],
        dof_length: &[MjtNum; "linear: 1; angular: approx. length scale"; ffi().nv],
        (mut = unsafe) tree_bodyadr: &[i32; "start addr of bodies"; ffi().ntree],
        (mut = unsafe) tree_bodynum: &[i32; "number of bodies in tree"; ffi().ntree],
        (mut = unsafe) tree_dofadr: &[i32; "start addr of dofs"; ffi().ntree],
        (mut = unsafe) tree_dofnum: &[i32; "number of dofs in tree"; ffi().ntree],
        tree_sleep_policy: &[MjtSleepPolicy [force]; "sleep policy"; ffi().ntree],
        (mut = unsafe) geom_type: &[MjtGeom [force]; "geometric type"; ffi().ngeom],
        geom_contype: &[i32; "geom contact type"; ffi().ngeom],
        geom_conaffinity: &[i32; "geom contact affinity"; ffi().ngeom],
        (mut = unsafe) geom_condim: &[i32; "contact dimensionality (1, 3, 4, 6)"; ffi().ngeom],
        (mut = unsafe) geom_bodyid: &[i32; "id of geom's body"; ffi().ngeom],
        (mut = unsafe) geom_dataid: &[i32; "id of geom's mesh/hfield; -1: none"; ffi().ngeom],
        (mut = unsafe) geom_matid: &[i32; "material id for rendering; -1: none"; ffi().ngeom],
        geom_group: &[i32; "group for visibility"; ffi().ngeom],
        geom_priority: &[i32; "geom contact priority"; ffi().ngeom],
        (mut = unsafe) geom_plugin: &[i32; "plugin instance id; -1: not in use"; ffi().ngeom],
        geom_sameframe: &[MjtSameFrame [force]; "same frame as body"; ffi().ngeom],
        geom_solmix: &[MjtNum; "mixing coef for solref/imp in geom pair"; ffi().ngeom],
        geom_solref: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference: contact"; ffi().ngeom],
        geom_solimp: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance: contact"; ffi().ngeom],
        geom_size: &[[MjtNum; 3] [force]; "geom-specific size parameters"; ffi().ngeom],
        geom_aabb: &[[MjtNum; 6] [force]; "bounding box, (center, size)"; ffi().ngeom],
        geom_rbound: &[MjtNum; "radius of bounding sphere"; ffi().ngeom],
        geom_pos: &[[MjtNum; 3] [force]; "local position offset rel. to body"; ffi().ngeom],
        geom_quat: &[[MjtNum; 4] [force]; "local orientation offset rel. to body"; ffi().ngeom],
        geom_friction: &[[MjtNum; 3] [force]; "friction for (slide, spin, roll)"; ffi().ngeom],
        geom_margin: &[MjtNum; "geometric inflation for contact"; ffi().ngeom],
        geom_gap: &[MjtNum; "additional contact detection buffer"; ffi().ngeom],
        geom_surfacevel: &[[MjtNum; 6] [force]; "surface velocity in local frame: lin,ang"; ffi().ngeom],
        geom_adhesion: &[MjtNum; "adhesive force of contacts"; ffi().ngeom],
        geom_fluid: &[[MjtNum; mjNFLUID as usize] [force]; "fluid interaction parameters"; ffi().ngeom],
        geom_rgba: &[[f32; 4] [force]; "rgba when material is omitted"; ffi().ngeom],
        site_type: &[MjtGeom [force]; "geom type for rendering"; ffi().nsite],
        (mut = unsafe) site_bodyid: &[i32; "id of site's body"; ffi().nsite],
        (mut = unsafe) site_matid: &[i32; "material id for rendering; -1: none"; ffi().nsite],
        site_group: &[i32; "group for visibility"; ffi().nsite],
        site_sameframe: &[MjtSameFrame [force]; "same frame as body"; ffi().nsite],
        site_size: &[[MjtNum; 3] [force]; "geom size for rendering"; ffi().nsite],
        site_pos: &[[MjtNum; 3] [force]; "local position offset rel. to body"; ffi().nsite],
        site_quat: &[[MjtNum; 4] [force]; "local orientation offset rel. to body"; ffi().nsite],
        site_rgba: &[[f32; 4] [force]; "rgba when material is omitted"; ffi().nsite],
        cam_mode: &[MjtCamLight [force]; "camera tracking mode"; ffi().ncam],
        (mut = unsafe) cam_bodyid: &[i32; "id of camera's body"; ffi().ncam],
        (mut = unsafe) cam_targetbodyid: &[i32; "id of targeted body; -1: none"; ffi().ncam],
        cam_pos: &[[MjtNum; 3] [force]; "position rel. to body frame"; ffi().ncam],
        cam_quat: &[[MjtNum; 4] [force]; "orientation rel. to body frame"; ffi().ncam],
        cam_poscom0: &[[MjtNum; 3] [force]; "global position rel. to sub-com in qpos0"; ffi().ncam],
        cam_pos0: &[[MjtNum; 3] [force]; "global position rel. to body in qpos0"; ffi().ncam],
        cam_mat0: &[[MjtNum; 9] [force]; "global orientation in qpos0"; ffi().ncam],
        cam_projection: &[MjtProjection [force]; "projection type"; ffi().ncam],
        cam_fovy: &[MjtNum; "y field-of-view (ortho ? len : deg)"; ffi().ncam],
        cam_ipd: &[MjtNum; "inter-pupillary distance"; ffi().ncam],
        (mut = unsafe) cam_resolution: &[[i32; 2] [force]; "resolution: pixels [width, height]"; ffi().ncam],
        cam_output: &[i32; "output types (MjtCamOutBit bit flags)"; ffi().ncam],
        cam_sensorsize: &[[f32; 2] [force]; "sensor size: length [width, height]"; ffi().ncam],
        cam_intrinsic: &[[f32; 4] [force]; "[focal length; principal point]"; ffi().ncam],
        light_mode: &[MjtCamLight [force]; "light tracking mode"; ffi().nlight],
        (mut = unsafe) light_bodyid: &[i32; "id of light's body"; ffi().nlight],
        (mut = unsafe) light_targetbodyid: &[i32; "id of targeted body; -1: none"; ffi().nlight],
        light_type: &[MjtLightType [force]; "spot, directional, etc."; ffi().nlight],
        (mut = unsafe) light_texid: &[i32; "texture id for image lights"; ffi().nlight],
        light_castshadow: &[MjtBool; "does light cast shadows"; ffi().nlight],
        light_bulbradius: &[f32; "light radius for soft shadows"; ffi().nlight],
        light_intensity: &[f32; "intensity, in candela"; ffi().nlight],
        light_range: &[f32; "range of effectiveness"; ffi().nlight],
        light_active: &[MjtBool; "is light on"; ffi().nlight],
        light_pos: &[[MjtNum; 3] [force]; "position rel. to body frame"; ffi().nlight],
        light_dir: &[[MjtNum; 3] [force]; "direction rel. to body frame"; ffi().nlight],
        light_poscom0: &[[MjtNum; 3] [force]; "global position rel. to sub-com in qpos0"; ffi().nlight],
        light_pos0: &[[MjtNum; 3] [force]; "global position rel. to body in qpos0"; ffi().nlight],
        light_dir0: &[[MjtNum; 3] [force]; "global direction in qpos0"; ffi().nlight],
        light_attenuation: &[[f32; 3] [force]; "OpenGL attenuation (quadratic model)"; ffi().nlight],
        light_cutoff: &[f32; "OpenGL cutoff"; ffi().nlight],
        light_softness: &[f32; "spotlight edge softness"; ffi().nlight],
        light_exponent: &[f32; "OpenGL exponent"; ffi().nlight],
        light_ambient: &[[f32; 3] [force]; "ambient rgb (alpha=1)"; ffi().nlight],
        light_diffuse: &[[f32; 3] [force]; "diffuse rgb (alpha=1)"; ffi().nlight],
        light_specular: &[[f32; 3] [force]; "specular rgb (alpha=1)"; ffi().nlight],
        flex_contype: &[i32; "flex contact type"; ffi().nflex],
        flex_conaffinity: &[i32; "flex contact affinity"; ffi().nflex],
        (mut = unsafe) flex_condim: &[i32; "contact dimensionality (1, 3, 4, 6)"; ffi().nflex],
        flex_priority: &[i32; "flex contact priority"; ffi().nflex],
        flex_solmix: &[MjtNum; "mix coef for solref/imp in contact pair"; ffi().nflex],
        flex_solref: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference: contact"; ffi().nflex],
        flex_solimp: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance: contact"; ffi().nflex],
        flex_friction: &[[MjtNum; 3] [force]; "friction for (slide, spin, roll)"; ffi().nflex],
        flex_margin: &[MjtNum; "geometric inflation for contact"; ffi().nflex],
        flex_gap: &[MjtNum; "additional contact detection buffer"; ffi().nflex],
        flex_internal: &[MjtBool; "internal flex collision enabled"; ffi().nflex],
        flex_selfcollide: &[MjtFlexSelf [force]; "self collision mode"; ffi().nflex],
        flex_activelayers: &[i32; "number of active element layers, 3D only"; ffi().nflex],
        flex_passive: &[i32; "passive collisions enabled"; ffi().nflex],
        (mut = unsafe) flex_dim: &[i32; "1: lines, 2: triangles, 3: tetrahedra"; ffi().nflex],
        (mut = unsafe) flex_matid: &[i32; "material id for rendering"; ffi().nflex],
        flex_group: &[i32; "group for visibility"; ffi().nflex],
        (mut = unsafe) flex_interp: &[i32; "interpolation (0: vertex, 1: nodes)"; ffi().nflex],
        (mut = unsafe) flex_cellnum: &[[i32; 3] [force]; "finite cell num per dimension"; ffi().nflex],
        (mut = unsafe) flex_nodeadr: &[i32; "first node address"; ffi().nflex],
        (mut = unsafe) flex_nodenum: &[i32; "number of nodes"; ffi().nflex],
        (mut = unsafe) flex_vertadr: &[i32; "first vertex address"; ffi().nflex],
        (mut = unsafe) flex_vertnum: &[i32; "number of vertices"; ffi().nflex],
        (mut = unsafe) flex_edgeadr: &[i32; "first edge address"; ffi().nflex],
        (mut = unsafe) flex_edgenum: &[i32; "number of edges"; ffi().nflex],
        (mut = unsafe) flex_elemadr: &[i32; "first element address"; ffi().nflex],
        (mut = unsafe) flex_elemnum: &[i32; "number of elements"; ffi().nflex],
        (mut = unsafe) flex_elemdataadr: &[i32; "first element vertex id address"; ffi().nflex],
        (mut = unsafe) flex_stiffnessadr: &[i32; "stiffness matrix address"; ffi().nflex],
        (mut = unsafe) flex_elemedgeadr: &[i32; "first element edge id address"; ffi().nflex],
        (mut = unsafe) flex_bendingadr: &[i32; "first bending data address"; ffi().nflex],
        (mut = unsafe) flex_shellnum: &[i32; "number of shells"; ffi().nflex],
        (mut = unsafe) flex_shelldataadr: &[i32; "first shell data address"; ffi().nflex],
        (mut = unsafe) flex_evpairadr: &[i32; "first evpair address"; ffi().nflex],
        (mut = unsafe) flex_evpairnum: &[i32; "number of evpairs"; ffi().nflex],
        (mut = unsafe) flex_texcoordadr: &[i32; "address in flex_texcoord; -1: none"; ffi().nflex],
        (mut = unsafe) flex_nodebodyid: &[i32; "node body ids"; ffi().nflexnode],
        (mut = unsafe) flex_vertbodyid: &[i32; "vertex body ids"; ffi().nflexvert],
        (mut = unsafe) flex_vertedgeadr: &[i32; "first edge address"; ffi().nflexvert],
        (mut = unsafe) flex_vertedgenum: &[i32; "number of edges"; ffi().nflexvert],
        (mut = unsafe) flex_vertedge: &[[i32; 2] [force]; "edge indices"; ffi().nflexedge],
        (mut = unsafe) flex_edge: &[[i32; 2] [force]; "edge vertex ids (2 per edge)"; ffi().nflexedge],
        (mut = unsafe) flex_edgeflap: &[[i32; 2] [force]; "adjacent vertex ids (dim=2 only)"; ffi().nflexedge],
        (mut = unsafe) flex_elem: &[i32; "element vertex ids (dim+1 per elem)"; ffi().nflexelemdata],
        (mut = unsafe) flex_elemtexcoord: &[i32; "element texture coordinates (dim+1)"; ffi().nflexelemdata],
        (mut = unsafe) flex_elemedge: &[i32; "element edge ids"; ffi().nflexelemedge],
        (mut = unsafe) flex_elemlayer: &[i32; "element distance from surface, 3D only"; ffi().nflexelem],
        (mut = unsafe) flex_shell: &[i32; "shell fragment vertex ids (dim per frag)"; ffi().nflexshelldata],
        (mut = unsafe) flex_evpair: &[[i32; 2] [force]; "(element, vertex) collision pairs"; ffi().nflexevpair],
        flex_vert: &[[MjtNum; 3] [force]; "vertex positions in local body frames"; ffi().nflexvert],
        flex_vert0: &[[MjtNum; 3] [force]; "vertex positions in qpos0 on [0, 1]^d"; ffi().nflexvert],
        flex_vertmetric: &[[MjtNum; 4] [force]; "inverse of reference shape matrix"; ffi().nflexvert],
        flex_node: &[[MjtNum; 3] [force]; "node positions in local body frames"; ffi().nflexnode],
        flex_node0: &[[MjtNum; 3] [force]; "Cartesian node positions in qpos0"; ffi().nflexnode],
        flexedge_length0: &[MjtNum; "edge lengths in qpos0"; ffi().nflexedge],
        flexedge_invweight0: &[MjtNum; "edge inv. weight in qpos0"; ffi().nflexedge],
        flex_radius: &[MjtNum; "radius around primitive element"; ffi().nflex],
        flex_size: &[[MjtNum; 3] [force]; "vertex bounding box half sizes in qpos0"; ffi().nflex],
        flex_stiffness: &[MjtNum; "finite element stiffness matrix"; ffi().nflexstiffness],
        flex_bending: &[MjtNum; "bending stiffness"; ffi().nflexbending],
        (mut = unsafe) efm0_dofid: &[i32; "constant metric factor row->dof address"; ffi().nefm0dof],
        (mut = unsafe) efm0_L_rownnz: &[i32; "constant metric factor row nonzeros"; ffi().nefm0dof],
        (mut = unsafe) efm0_L_rowadr: &[i32; "constant metric factor row addresses"; ffi().nefm0dof],
        (mut = unsafe) efm0_L_colind: &[i32; "constant metric factor column indices"; ffi().nefm0L],
        efm0_L: &[MjtNum; "factor of M + (dt^2+dt*d)*K_bend"; ffi().nefm0L],
        flex_damping: &[MjtNum; "Rayleigh's damping coefficient"; ffi().nflex],
        flex_edgestiffness: &[MjtNum; "edge stiffness"; ffi().nflex],
        flex_edgedamping: &[MjtNum; "edge damping"; ffi().nflex],
        flex_edgeequality: &[i32; "0: none, 1: edges, 2: vertices, 3: strain"; ffi().nflex],
        flex_rigid: &[MjtBool; "are all vertices in the same body"; ffi().nflex],
        flexedge_rigid: &[MjtBool; "are both edge vertices in same body"; ffi().nflexedge],
        flex_centered: &[MjtBool; "are all vertex coordinates (0,0,0)"; ffi().nflex],
        flex_flatskin: &[MjtBool; "render flex skin with flat shading"; ffi().nflex],
        (mut = unsafe) flex_bvhadr: &[i32; "address of bvh root; -1: no bvh"; ffi().nflex],
        (mut = unsafe) flex_bvhnum: &[i32; "number of bounding volumes"; ffi().nflex],
        (mut = unsafe) flexedge_J_rownnz: &[i32; "number of non-zeros in Jacobian row"; ffi().nflexedge],
        (mut = unsafe) flexedge_J_rowadr: &[i32; "row start address in colind array"; ffi().nflexedge],
        (mut = unsafe) flexedge_J_colind: &[i32; "column indices in sparse Jacobian"; ffi().nJfe],
        (mut = unsafe) flexvert_J_rownnz: &[[i32; 2] [force]; "number of non-zeros in Jacobian row"; ffi().nflexvert],
        (mut = unsafe) flexvert_J_rowadr: &[[i32; 2] [force]; "row start address in colind array"; ffi().nflexvert],
        (mut = unsafe) flexvert_J_colind: &[[i32; 2] [force]; "column indices in sparse Jacobian"; ffi().nJfv],
        flex_rgba: &[[f32; 4] [force]; "rgba when material is omitted"; ffi().nflex],
        flex_texcoord: &[[f32; 2] [force]; "vertex texture coordinates"; ffi().nflextexcoord],
        (mut = unsafe) mesh_vertadr: &[i32; "first vertex address"; ffi().nmesh],
        (mut = unsafe) mesh_vertnum: &[i32; "number of vertices"; ffi().nmesh],
        (mut = unsafe) mesh_faceadr: &[i32; "first face address"; ffi().nmesh],
        (mut = unsafe) mesh_facenum: &[i32; "number of faces"; ffi().nmesh],
        (mut = unsafe) mesh_bvhadr: &[i32; "address of bvh root"; ffi().nmesh],
        (mut = unsafe) mesh_bvhnum: &[i32; "number of bvh"; ffi().nmesh],
        (mut = unsafe) mesh_octadr: &[i32; "address of octree root"; ffi().nmesh],
        (mut = unsafe) mesh_octnum: &[i32; "number of octree nodes"; ffi().nmesh],
        (mut = unsafe) mesh_normaladr: &[i32; "first normal address"; ffi().nmesh],
        (mut = unsafe) mesh_normalnum: &[i32; "number of normals"; ffi().nmesh],
        (mut = unsafe) mesh_texcoordadr: &[i32; "texcoord data address; -1: no texcoord"; ffi().nmesh],
        (mut = unsafe) mesh_texcoordnum: &[i32; "number of texcoord"; ffi().nmesh],
        (mut = unsafe) mesh_graphadr: &[i32; "graph data address; -1: no graph"; ffi().nmesh],
        (mut = unsafe) mesh_extrema: &[[i32; 27] [force]; "extremum vertices in 3x3x3 directions"; ffi().nmesh],
        mesh_vert: &[[f32; 3] [force]; "vertex positions for all meshes"; ffi().nmeshvert],
        mesh_normal: &[[f32; 3] [force]; "normals for all meshes"; ffi().nmeshnormal],
        mesh_texcoord: &[[f32; 2] [force]; "vertex texcoords for all meshes"; ffi().nmeshtexcoord],
        (mut = unsafe) mesh_face: &[[i32; 3] [force]; "vertex face data"; ffi().nmeshface],
        (mut = unsafe) mesh_facenormal: &[[i32; 3] [force]; "normal face data"; ffi().nmeshface],
        (mut = unsafe) mesh_facetexcoord: &[[i32; 3] [force]; "texture face data"; ffi().nmeshface],
        (mut = unsafe) mesh_graph: &[i32; "convex graph data"; ffi().nmeshgraph],
        mesh_scale: &[[MjtNum; 3] [force]; "scaling applied to asset vertices"; ffi().nmesh],
        mesh_pos: &[[MjtNum; 3] [force]; "translation applied to asset vertices"; ffi().nmesh],
        mesh_quat: &[[MjtNum; 4] [force]; "rotation applied to asset vertices"; ffi().nmesh],
        (mut = unsafe) mesh_pathadr: &[i32; "address of asset path for mesh; -1: none"; ffi().nmesh],
        (mut = unsafe) mesh_polynum: &[i32; "number of polygons per mesh"; ffi().nmesh],
        (mut = unsafe) mesh_polyadr: &[i32; "first polygon address per mesh"; ffi().nmesh],
        mesh_polynormal: &[[MjtNum; 3] [force]; "all polygon normals"; ffi().nmeshpoly],
        (mut = unsafe) mesh_polyvertadr: &[i32; "polygon vertex start address"; ffi().nmeshpoly],
        (mut = unsafe) mesh_polyvertnum: &[i32; "number of vertices per polygon"; ffi().nmeshpoly],
        (mut = unsafe) mesh_polyvert: &[i32; "all polygon vertices"; ffi().nmeshpolyvert],
        (mut = unsafe) mesh_polymapadr: &[i32; "first polygon address per vertex"; ffi().nmeshvert],
        (mut = unsafe) mesh_polymapnum: &[i32; "number of polygons per vertex"; ffi().nmeshvert],
        (mut = unsafe) mesh_polymap: &[i32; "vertex to polygon map"; ffi().nmeshpolymap],
        (mut = unsafe) skin_matid: &[i32; "skin material id; -1: none"; ffi().nskin],
        skin_group: &[i32; "group for visibility"; ffi().nskin],
        skin_rgba: &[[f32; 4] [force]; "skin rgba"; ffi().nskin],
        skin_inflate: &[f32; "inflate skin in normal direction"; ffi().nskin],
        (mut = unsafe) skin_vertadr: &[i32; "first vertex address"; ffi().nskin],
        (mut = unsafe) skin_vertnum: &[i32; "number of vertices"; ffi().nskin],
        (mut = unsafe) skin_texcoordadr: &[i32; "texcoord data address; -1: no texcoord"; ffi().nskin],
        (mut = unsafe) skin_faceadr: &[i32; "first face address"; ffi().nskin],
        (mut = unsafe) skin_facenum: &[i32; "number of faces"; ffi().nskin],
        (mut = unsafe) skin_boneadr: &[i32; "first bone in skin"; ffi().nskin],
        (mut = unsafe) skin_bonenum: &[i32; "number of bones in skin"; ffi().nskin],
        skin_vert: &[[f32; 3] [force]; "vertex positions for all skin meshes"; ffi().nskinvert],
        skin_texcoord: &[[f32; 2] [force]; "vertex texcoords for all skin meshes"; ffi().nskintexvert],
        (mut = unsafe) skin_face: &[[i32; 3] [force]; "triangle faces for all skin meshes"; ffi().nskinface],
        (mut = unsafe) skin_bonevertadr: &[i32; "first vertex in each bone"; ffi().nskinbone],
        (mut = unsafe) skin_bonevertnum: &[i32; "number of vertices in each bone"; ffi().nskinbone],
        skin_bonebindpos: &[[f32; 3] [force]; "bind pos of each bone"; ffi().nskinbone],
        skin_bonebindquat: &[[f32; 4] [force]; "bind quat of each bone"; ffi().nskinbone],
        (mut = unsafe) skin_bonebodyid: &[i32; "body id of each bone"; ffi().nskinbone],
        (mut = unsafe) skin_bonevertid: &[i32; "mesh ids of vertices in each bone"; ffi().nskinbonevert],
        skin_bonevertweight: &[f32; "weights of vertices in each bone"; ffi().nskinbonevert],
        (mut = unsafe) skin_pathadr: &[i32; "address of asset path for skin; -1: none"; ffi().nskin],
        hfield_size: &[[MjtNum; 4] [force]; "(x, y, z_top, z_bottom)"; ffi().nhfield],
        (mut = unsafe) hfield_nrow: &[i32; "number of rows in grid"; ffi().nhfield],
        (mut = unsafe) hfield_ncol: &[i32; "number of columns in grid"; ffi().nhfield],
        (mut = unsafe) hfield_adr: &[i32; "address in hfield_data"; ffi().nhfield],
        hfield_data: &[f32; "elevation data"; ffi().nhfielddata],
        (mut = unsafe) hfield_pathadr: &[i32; "address of hfield asset path; -1: none"; ffi().nhfield],
        (mut = unsafe) tex_type: &[MjtTexture [force]; "texture type"; ffi().ntex],
        tex_colorspace: &[MjtColorSpace [force]; "texture colorspace"; ffi().ntex],
        (mut = unsafe) tex_height: &[i32; "number of rows in texture image"; ffi().ntex],
        (mut = unsafe) tex_width: &[i32; "number of columns in texture image"; ffi().ntex],
        (mut = unsafe) tex_nchannel: &[i32; "number of channels in texture image"; ffi().ntex],
        (mut = unsafe) tex_adr: &[MjtSize; "start address in tex_data"; ffi().ntex],
        tex_data: &[MjtByte; "pixel values"; ffi().ntexdata],
        (mut = unsafe) tex_pathadr: &[i32; "address of texture asset path; -1: none"; ffi().ntex],
        (mut = unsafe) mat_texid: &[[i32; MjtTextureRole::mjNTEXROLE as usize] [force]; "indices of textures; -1: none"; ffi().nmat],
        mat_texuniform: &[MjtBool; "make texture cube uniform"; ffi().nmat],
        mat_texrepeat: &[[f32; 2] [force]; "texture repetition for 2d mapping"; ffi().nmat],
        mat_emission: &[f32; "emission (x rgb)"; ffi().nmat],
        mat_specular: &[f32; "specular (x white)"; ffi().nmat],
        mat_shininess: &[f32; "shininess coef"; ffi().nmat],
        mat_reflectance: &[f32; "reflectance (0: disable)"; ffi().nmat],
        mat_metallic: &[f32; "metallic coef"; ffi().nmat],
        mat_roughness: &[f32; "roughness coef"; ffi().nmat],
        mat_rgba: &[[f32; 4] [force]; "rgba"; ffi().nmat],
        (mut = unsafe) pair_dim: &[i32; "contact dimensionality"; ffi().npair],
        (mut = unsafe) pair_geom1: &[i32; "id of geom1"; ffi().npair],
        (mut = unsafe) pair_geom2: &[i32; "id of geom2"; ffi().npair],
        pair_signature: &[i32; "body1 << 16 + body2"; ffi().npair],
        pair_solref: &[[MjtNum; mjNREF as usize] [force]; "solver reference: contact normal"; ffi().npair],
        pair_solreffriction: &[[MjtNum; mjNREF as usize] [force]; "solver reference: contact friction"; ffi().npair],
        pair_solimp: &[[MjtNum; mjNIMP as usize] [force]; "solver impedance: contact"; ffi().npair],
        pair_margin: &[MjtNum; "geometric inflation for contact"; ffi().npair],
        pair_gap: &[MjtNum; "additional contact detection buffer"; ffi().npair],
        pair_adhesion: &[MjtNum; "adhesive force of contacts"; ffi().npair],
        pair_friction: &[[MjtNum; 5] [force]; "tangent1, 2, spin, roll1, 2"; ffi().npair],
        exclude_signature: &[i32; "body1 << 16 + body2"; ffi().nexclude],
        (mut = unsafe) eq_type: &[MjtEq [force]; "constraint type"; ffi().neq],
        (mut = unsafe) eq_obj1id: &[i32; "id of object 1"; ffi().neq],
        (mut = unsafe) eq_obj2id: &[i32; "id of object 2"; ffi().neq],
        (mut = unsafe) eq_objtype: &[MjtObj [force]; "type of both objects"; ffi().neq],
        eq_active0: &[MjtBool; "initial enable/disable constraint state"; ffi().neq],
        eq_solref: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference"; ffi().neq],
        eq_solimp: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance"; ffi().neq],
        eq_data: &[[MjtNum; mjNEQDATA as usize] [force]; "numeric data for constraint"; ffi().neq],
        (mut = unsafe) tendon_adr: &[i32; "address of first object in tendon's path"; ffi().ntendon],
        (mut = unsafe) tendon_num: &[i32; "number of objects in tendon's path"; ffi().ntendon],
        (mut = unsafe) tendon_matid: &[i32; "material id for rendering"; ffi().ntendon],
        (mut = unsafe) tendon_actuatorid: &[i32; "actuator contributing damping / armature"; ffi().ntendon],
        tendon_group: &[i32; "group for visibility"; ffi().ntendon],
        tendon_treenum: &[i32; "number of trees along tendon's path"; ffi().ntendon],
        (mut = unsafe) tendon_treeid: &[[i32; 2] [force]; "first two trees along tendon's path"; ffi().ntendon],
        (mut = unsafe) ten_J_rownnz: &[i32; "number of non-zeros in Jacobian row"; ffi().ntendon],
        (mut = unsafe) ten_J_rowadr: &[i32; "row start address in colind array"; ffi().ntendon],
        (mut = unsafe) ten_J_colind: &[i32; "column indices in sparse Jacobian"; ffi().nJten],
        tendon_limited: &[MjtBool; "does tendon have length limits"; ffi().ntendon],
        tendon_actfrclimited: &[MjtBool; "does tendon have actuator force limits"; ffi().ntendon],
        tendon_width: &[MjtNum; "width for rendering"; ffi().ntendon],
        tendon_solref_lim: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference: limit"; ffi().ntendon],
        tendon_solimp_lim: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance: limit"; ffi().ntendon],
        tendon_solref_fri: &[[MjtNum; mjNREF as usize] [force]; "constraint solver reference: friction"; ffi().ntendon],
        tendon_solimp_fri: &[[MjtNum; mjNIMP as usize] [force]; "constraint solver impedance: friction"; ffi().ntendon],
        tendon_range: &[[MjtNum; 2] [force]; "tendon length limits"; ffi().ntendon],
        tendon_actfrcrange: &[[MjtNum; 2] [force]; "range of total actuator force"; ffi().ntendon],
        tendon_margin: &[MjtNum; "min distance for limit detection"; ffi().ntendon],
        tendon_stiffness: &[MjtNum; "linear stiffness coefficient"; ffi().ntendon],
        tendon_stiffnesspoly: &[[MjtNum; mjNPOLY as usize] [force]; "high-order stiffness coefficients"; ffi().ntendon],
        tendon_damping: &[MjtNum; "linear damping coefficient"; ffi().ntendon],
        tendon_dampingpoly: &[[MjtNum; mjNPOLY as usize] [force]; "high-order damping coefficients"; ffi().ntendon],
        tendon_armature: &[MjtNum; "inertia associated with tendon velocity"; ffi().ntendon],
        tendon_frictionloss: &[MjtNum; "loss due to friction"; ffi().ntendon],
        tendon_lengthspring: &[[MjtNum; 2] [force]; "spring resting length range"; ffi().ntendon],
        tendon_length0: &[MjtNum; "tendon length in qpos0"; ffi().ntendon],
        tendon_invweight0: &[MjtNum; "inv. weight in qpos0"; ffi().ntendon],
        tendon_rgba: &[[f32; 4] [force]; "rgba when material is omitted"; ffi().ntendon],
        (mut = unsafe) wrap_type: &[MjtWrap [force]; "wrap object type"; ffi().nwrap],
        (mut = unsafe) wrap_objid: &[i32; "object id: geom, site, joint"; ffi().nwrap],
        (mut = unsafe) wrap_prm: &[MjtNum; "divisor, joint coef, or site id"; ffi().nwrap],
        (mut = unsafe) actuator_trntype: &[MjtTrn [force]; "transmission type"; ffi().nactuator],
        (mut = unsafe) actuator_dyntype: &[MjtDyn [force]; "dynamics type"; ffi().nactuator],
        (mut = unsafe) actuator_gaintype: &[MjtGain [force]; "gain type"; ffi().nactuator],
        actuator_biastype: &[MjtBias [force]; "bias type"; ffi().nactuator],
        (mut = unsafe) actuator_ctrladr: &[i32; "address of first control"; ffi().nactuator],
        (mut = unsafe) actuator_ctrlnum: &[i32; "number of controls"; ffi().nactuator],
        (mut = unsafe) actuator_ctrlspec: &[i32; "input signature, scoped by gaintype"; ffi().nactuator],
        (mut = unsafe) actuator_outadr: &[i32; "address of first force output"; ffi().nactuator],
        (mut = unsafe) actuator_outnum: &[i32; "number of force outputs, from trntype"; ffi().nactuator],
        (mut = unsafe) actuator_trnid: &[[i32; 2] [force]; "transmission id: joint, tendon, site"; ffi().nactuator],
        (mut = unsafe) actuator_actadr: &[i32; "first activation address; -1: stateless"; ffi().nactuator],
        (mut = unsafe) actuator_actnum: &[i32; "number of activation variables"; ffi().nactuator],
        actuator_group: &[i32; "group for visibility"; ffi().nactuator],
        (mut = unsafe) actuator_history: &[[i32; 2] [force]; "history buffer: [nsample, interp]"; ffi().nactuator],
        (mut = unsafe) actuator_historyadr: &[i32; "address in history buffer; -1: none"; ffi().nactuator],
        actuator_delay: &[MjtNum; "delay time in seconds; 0: no delay"; ffi().nactuator],
        actuator_ctrllimited: &[MjtBool; "is control limited"; ffi().nu],
        actuator_forcelimited: &[MjtBool; "is force limited"; ffi().nactuator],
        actuator_actlimited: &[MjtBool; "is activation limited"; ffi().nactuator],
        actuator_dynprm: &[[MjtNum; mjNDYN as usize] [force]; "dynamics parameters"; ffi().nactuator],
        actuator_gainprm: &[[MjtNum; mjNGAIN as usize] [force]; "gain parameters"; ffi().nactuator],
        actuator_biasprm: &[[MjtNum; mjNBIAS as usize] [force]; "bias parameters"; ffi().nactuator],
        actuator_actearly: &[MjtBool; "step activation before force"; ffi().nactuator],
        actuator_ctrlrange: &[[MjtNum; 2] [force]; "range of controls"; ffi().nu],
        actuator_forcerange: &[[MjtNum; 2] [force]; "range of forces"; ffi().nactuator],
        actuator_actrange: &[[MjtNum; 2] [force]; "range of activations"; ffi().nactuator],
        actuator_damping: &[MjtNum; "linear damping coefficient"; ffi().nactuator],
        actuator_dampingpoly: &[[MjtNum; mjNPOLY as usize] [force]; "high-order damping coefficients"; ffi().nactuator],
        actuator_armature: &[MjtNum; "armature added to target (joint, tendon)"; ffi().nactuator],
        actuator_gear: &[[MjtNum; 6] [force]; "scale length and transmitted force"; ffi().nout],
        actuator_cranklength: &[MjtNum; "crank length for slider-crank"; ffi().nactuator],
        actuator_acc0: &[MjtNum; "acceleration from unit force in qpos0"; ffi().nout],
        actuator_length0: &[MjtNum; "actuator length in qpos0"; ffi().nout],
        actuator_lengthrange: &[[MjtNum; 2] [force]; "feasible actuator length range"; ffi().nout],
        (mut = unsafe) actuator_plugin: &[i32; "plugin instance id; -1: not a plugin"; ffi().nactuator],
        (mut = unsafe) sensor_type: &[MjtSensor [force]; "sensor type"; ffi().nsensor],
        sensor_datatype: &[MjtDataType [force]; "numeric data type"; ffi().nsensor],
        sensor_needstage: &[MjtStage [force]; "required compute stage"; ffi().nsensor],
        (mut = unsafe) sensor_objtype: &[MjtObj [force]; "type of sensorized object"; ffi().nsensor],
        (mut = unsafe) sensor_objid: &[i32; "id of sensorized object"; ffi().nsensor],
        (mut = unsafe) sensor_reftype: &[MjtObj [force]; "type of reference frame"; ffi().nsensor],
        (mut = unsafe) sensor_refid: &[i32; "id of reference frame; -1: global frame"; ffi().nsensor],
        (mut = unsafe) sensor_intprm: &[[i32; mjNSENS as usize] [force]; "sensor parameters"; ffi().nsensor],
        (mut = unsafe) sensor_dim: &[i32; "number of scalar outputs"; ffi().nsensor],
        (mut = unsafe) sensor_adr: &[i32; "address in sensor array"; ffi().nsensor],
        sensor_cutoff: &[MjtNum; "cutoff for real and positive; 0: ignore"; ffi().nsensor],
        sensor_noise: &[MjtNum; "noise standard deviation"; ffi().nsensor],
        (mut = unsafe) sensor_history: &[[i32; 2] [force]; "history buffer: [nsample, interp]"; ffi().nsensor],
        (mut = unsafe) sensor_historyadr: &[i32; "address in history buffer; -1: none"; ffi().nsensor],
        sensor_delay: &[MjtNum; "delay time in seconds; 0: no delay"; ffi().nsensor],
        sensor_interval: &[[MjtNum; 2] [force]; "interval: [period, phase] in seconds"; ffi().nsensor],
        (mut = unsafe) sensor_plugin: &[i32; "plugin instance id; -1: not a plugin"; ffi().nsensor],
        (mut = unsafe) plugin: &[i32; "globally registered plugin slot number"; ffi().nplugin],
        (mut = unsafe) plugin_stateadr: &[i32; "address in the plugin state array"; ffi().nplugin],
        (mut = unsafe) plugin_statenum: &[i32; "number of states in the plugin instance"; ffi().nplugin],
        (mut = unsafe) plugin_attr: &[c_char; "config attributes of plugin instances"; ffi().npluginattr],
        (mut = unsafe) plugin_attradr: &[i32; "address to each instance's config attrib"; ffi().nplugin],
        (mut = unsafe) numeric_adr: &[i32; "address of field in numeric_data"; ffi().nnumeric],
        (mut = unsafe) numeric_size: &[i32; "size of numeric field"; ffi().nnumeric],
        numeric_data: &[MjtNum; "array of all numeric fields"; ffi().nnumericdata],
        (mut = unsafe) text_adr: &[i32; "address of text in text_data"; ffi().ntext],
        (mut = unsafe) text_size: &[i32; "size of text field (strlen+1)"; ffi().ntext],
        (mut = unsafe) text_data: &[c_char; "array of all text fields (0-terminated)"; ffi().ntextdata],
        (mut = unsafe) tuple_adr: &[i32; "address of tuple in tuple_objtype/objid/objprm"; ffi().ntuple],
        (mut = unsafe) tuple_size: &[i32; "number of objects in tuple"; ffi().ntuple],
        tuple_objtype: &[MjtObj [force]; "array of object types in all tuples"; ffi().ntupledata],
        (mut = unsafe) tuple_objid: &[i32; "array of object ids in all tuples"; ffi().ntupledata],
        tuple_objprm: &[MjtNum; "array of object params in all tuples"; ffi().ntupledata],
        key_time: &[MjtNum; "key time"; ffi().nkey],
        (mut = unsafe) name_bodyadr: &[i32; "body name pointers"; ffi().nbody],
        (mut = unsafe) name_jntadr: &[i32; "joint name pointers"; ffi().njnt],
        (mut = unsafe) name_geomadr: &[i32; "geom name pointers"; ffi().ngeom],
        (mut = unsafe) name_siteadr: &[i32; "site name pointers"; ffi().nsite],
        (mut = unsafe) name_camadr: &[i32; "camera name pointers"; ffi().ncam],
        (mut = unsafe) name_lightadr: &[i32; "light name pointers"; ffi().nlight],
        (mut = unsafe) name_flexadr: &[i32; "flex name pointers"; ffi().nflex],
        (mut = unsafe) name_meshadr: &[i32; "mesh name pointers"; ffi().nmesh],
        (mut = unsafe) name_skinadr: &[i32; "skin name pointers"; ffi().nskin],
        (mut = unsafe) name_hfieldadr: &[i32; "hfield name pointers"; ffi().nhfield],
        (mut = unsafe) name_texadr: &[i32; "texture name pointers"; ffi().ntex],
        (mut = unsafe) name_matadr: &[i32; "material name pointers"; ffi().nmat],
        (mut = unsafe) name_pairadr: &[i32; "geom pair name pointers"; ffi().npair],
        (mut = unsafe) name_excludeadr: &[i32; "exclude name pointers"; ffi().nexclude],
        (mut = unsafe) name_eqadr: &[i32; "equality constraint name pointers"; ffi().neq],
        (mut = unsafe) name_tendonadr: &[i32; "tendon name pointers"; ffi().ntendon],
        (mut = unsafe) name_actuatoradr: &[i32; "actuator name pointers"; ffi().nactuator],
        (mut = unsafe) name_sensoradr: &[i32; "sensor name pointers"; ffi().nsensor],
        (mut = unsafe) name_numericadr: &[i32; "numeric name pointers"; ffi().nnumeric],
        (mut = unsafe) name_textadr: &[i32; "text name pointers"; ffi().ntext],
        (mut = unsafe) name_tupleadr: &[i32; "tuple name pointers"; ffi().ntuple],
        (mut = unsafe) name_keyadr: &[i32; "keyframe name pointers"; ffi().nkey],
        (mut = unsafe) name_pluginadr: &[i32; "plugin instance name pointers"; ffi().nplugin],
        (mut = unsafe) names: &[c_char; "names of all objects, 0-terminated"; ffi().nnames],
        (mut = unsafe) names_map: &[i32; "internal hash map of names"; ffi().nnames_map],
        paths: &[c_char; "paths to assets, 0-terminated"; ffi().npaths],
        (mut = unsafe) B_rownnz: &[i32; "body-dof: non-zeros in each row"; ffi().nbody],
        (mut = unsafe) B_rowadr: &[i32; "body-dof: row addresses"; ffi().nbody],
        (mut = unsafe) B_colind: &[i32; "body-dof: column indices"; ffi().nB],
        (mut = unsafe) M_rownnz: &[i32; "reduced inertia: non-zeros in each row"; ffi().nv],
        (mut = unsafe) M_rowadr: &[i32; "reduced inertia: row addresses"; ffi().nv],
        (mut = unsafe) M_colind: &[i32; "reduced inertia: column indices"; ffi().nC],
        (mut = unsafe) mapM2M: &[i32; "index mapping from qM to M"; ffi().nC],
        (mut = unsafe) D_rownnz: &[i32; "full inertia: non-zeros in each row"; ffi().nv],
        (mut = unsafe) D_rowadr: &[i32; "full inertia: row addresses"; ffi().nv],
        (mut = unsafe) D_diag: &[i32; "full inertia: index of diagonal element"; ffi().nv],
        (mut = unsafe) D_colind: &[i32; "full inertia: column indices"; ffi().nD],
        (mut = unsafe) mapM2D: &[i32; "index mapping from M to D"; ffi().nD],
        (mut = unsafe) mapD2M: &[i32; "index mapping from D to M"; ffi().nC]
    }

    array_slice_dyn! {
        sublen_dep {
            key_qpos: &[[MjtNum; ffi().nq] [force]; "key position"; ffi().nkey],
            key_qvel: &[[MjtNum; ffi().nv] [force]; "key velocity"; ffi().nkey],
            key_act: &[[MjtNum; ffi().na] [force]; "key activation"; ffi().nkey],
            key_mpos: &[[MjtNum; ffi().nmocap * 3] [force]; "key mocap position"; ffi().nkey],
            key_mquat: &[[MjtNum; ffi().nmocap * 4] [force]; "key mocap quaternion"; ffi().nkey],
            key_ctrl: &[[MjtNum; ffi().nu] [force]; "key control"; ffi().nkey],

            sensor_user: &[[MjtNum; ffi().nuser_sensor] [force]; "user data"; ffi().nsensor],
            actuator_user: &[[MjtNum; ffi().nuser_actuator] [force]; "user data"; ffi().nactuator],
            tendon_user: &[[MjtNum; ffi().nuser_tendon] [force]; "user data"; ffi().ntendon],
            cam_user: &[[MjtNum; ffi().nuser_cam] [force]; "user data"; ffi().ncam],
            site_user: &[[MjtNum; ffi().nuser_site] [force]; "user data"; ffi().nsite],
            geom_user: &[[MjtNum; ffi().nuser_geom] [force]; "user data"; ffi().ngeom],
            jnt_user: &[[MjtNum; ffi().nuser_jnt] [force]; "user data"; ffi().njnt],
            body_user: &[[MjtNum; ffi().nuser_body] [force]; "user data"; ffi().nbody]
        }
    }
}

impl Clone for MjModel {
    /// # Note
    /// MuJoCo aborts the process through `mjERROR` when an allocation fails, so this never fails.
    #[expect(deprecated, reason = "try_clone keeps the implementation until it is removed")]
    fn clone(&self) -> Self {
        self.try_clone().expect("failed to clone model")
    }
}

impl Drop for MjModel {
    fn drop(&mut self) {
        // SAFETY: self.ptr is a valid non-null mjModel pointer; called exactly once in Drop.
        unsafe {
            mj_deleteModel(self.ptr.as_ptr());
        }
    }
}

info_with_view!(Model, actuator,
	[[actuator_] group: i32,
	 [actuator_] delay: MjtNum, [actuator_] ctrllimited: MjtBool,
	 [actuator_] forcelimited: MjtBool, [actuator_] actlimited: MjtBool,
	 [actuator_] dynprm: MjtNum, [actuator_] gainprm: MjtNum,
	 [actuator_] biasprm: MjtNum, [actuator_] actearly: MjtBool,
	 [actuator_] ctrlrange: MjtNum, [actuator_] forcerange: MjtNum,
	 [actuator_] actrange: MjtNum, [actuator_] gear: MjtNum,
	 [actuator_] damping: MjtNum, [actuator_] dampingpoly: MjtNum,
	 [actuator_] armature: MjtNum,
	 [actuator_] cranklength: MjtNum, [actuator_] acc0: MjtNum,
	 [actuator_] length0: MjtNum, [actuator_] lengthrange: MjtNum,
	 [actuator_] user: MjtNum, [actuator_] biastype: MjtBias [force],
	 [actuator_] plugin: i32],
	[[actuator_] trntype: MjtTrn [force], [actuator_] dyntype: MjtDyn [force],
	 [actuator_] ctrladr: i32, [actuator_] ctrlnum: i32, [actuator_] ctrlspec: i32,
	 [actuator_] gaintype: MjtGain [force],
	 [actuator_] outadr: i32, [actuator_] outnum: i32,
	 [actuator_] trnid: i32, [actuator_] actadr: i32,
	 [actuator_] actnum: i32, [actuator_] history: i32,
	 [actuator_] historyadr: i32],
	[]);

info_with_view!(Model, body,
	[[body_] sameframe: MjtSameFrame [force],
	 [body_] pos: MjtNum,
	 [body_] quat: MjtNum, [body_] ipos: MjtNum,
	 [body_] iquat: MjtNum, [body_] mass: MjtNum,
	 [body_] subtreemass: MjtNum, [body_] inertia: MjtNum,
	 [body_] invweight0: MjtNum, [body_] gravcomp: MjtNum,
	 [body_] margin: MjtNum,
	 [body_] contype: i32, [body_] conaffinity: i32,
	 [body_] user: MjtNum,
	 [body_] simple: MjtByte, [body_] plugin: i32],
	[[body_] parentid: i32, [body_] rootid: i32,
	 [body_] weldid: i32, [body_] mocapid: i32,
	 [body_] jntnum: i32, [body_] jntadr: i32,
	 [body_] dofnum: i32, [body_] dofadr: i32,
	 [body_] treeid: i32, [body_] geomnum: i32,
	 [body_] geomadr: i32,
	 [body_] bvhadr: i32, [body_] bvhnum: i32],
	[]);

info_with_view!(Model, camera,
	[[cam_] mode: MjtCamLight [force],
	 [cam_] pos: MjtNum,
	 [cam_] quat: MjtNum,
	 [cam_] poscom0: MjtNum,
	 [cam_] pos0: MjtNum,
	 [cam_] mat0: MjtNum,
	 [cam_] projection: MjtProjection [force],
	 [cam_] fovy: MjtNum,
	 [cam_] ipd: MjtNum,
     [cam_] output: i32,
	 [cam_] sensorsize: f32,
	 [cam_] intrinsic: f32,
	 [cam_] user: MjtNum],
	[[cam_] bodyid: i32,
	 [cam_] targetbodyid: i32,
	 [cam_] resolution: i32],
	[]);

info_with_view!(Model, equality,
	[[eq_] active0: MjtBool,
	 [eq_] solref: MjtNum,
	 [eq_] solimp: MjtNum,
	 [eq_] data: MjtNum],
	[[eq_] r#type: MjtEq [force],
	 [eq_] obj1id: i32,
	 [eq_] obj2id: i32,
     [eq_] objtype: MjtObj [force]],
	[]);

info_with_view!(Model, exclude,
	[[exclude_] signature: i32],
	[],
	[]);

info_with_view!(Model, geom,
	[[geom_] contype: i32,
	 [geom_] conaffinity: i32,
	 [geom_] group: i32,
	 [geom_] priority: i32, [geom_] sameframe: MjtSameFrame [force],
	 [geom_] solmix: MjtNum, [geom_] solref: MjtNum,
	 [geom_] solimp: MjtNum, [geom_] size: MjtNum,
	 [geom_] aabb: MjtNum,
	 [geom_] rbound: MjtNum, [geom_] pos: MjtNum,
	 [geom_] quat: MjtNum, [geom_] friction: MjtNum,
	 [geom_] margin: MjtNum, [geom_] gap: MjtNum,
	 [geom_] surfacevel: MjtNum, [geom_] adhesion: MjtNum, [geom_] fluid: MjtNum,
	 [geom_] user: MjtNum, [geom_] rgba: f32],
	[[geom_] r#type: MjtGeom [force], [geom_] condim: i32,
	 [geom_] bodyid: i32, [geom_] dataid: i32,
	 [geom_] matid: i32, [geom_] plugin: i32],
	[]);

info_with_view!(Model, hfield,
	[[hfield_] size: MjtNum],
	[[hfield_] nrow: i32,
	 [hfield_] ncol: i32,
	 [hfield_] adr: i32,
     [hfield_] pathadr: i32],
	[[hfield_] data: f32]);

info_with_view!(Model, joint,
	[qpos0: MjtNum, qpos_spring: MjtNum,
     [jnt_] group: i32,
     [jnt_] limited: MjtBool, [jnt_] actfrclimited: MjtBool, [jnt_] actgravcomp: MjtBool,
	 [jnt_] solref: MjtNum, [jnt_] solimp: MjtNum,
	 [jnt_] pos: MjtNum,
     [jnt_] axis: MjtNum, [jnt_] stiffness: MjtNum,
     [jnt_] stiffnesspoly: MjtNum,
     [jnt_] range: MjtNum, [jnt_] actfrcrange: MjtNum, [jnt_] margin: MjtNum,
     [jnt_] user: MjtNum,
     [dof_] frictionloss: MjtNum, [dof_] armature: MjtNum,
     [dof_] damping: MjtNum,
     [dof_] dampingpoly: MjtNum,
     [dof_] invweight0: MjtNum,
     [dof_] M0: MjtNum,
     [dof_] simplenum: i32],
	[[jnt_] r#type: MjtJoint [force],
     [jnt_] qposadr: i32,
     [jnt_] dofadr: i32, [jnt_] bodyid: i32, [jnt_] actuatorid: i32,
     dof_bodyid: i32, [dof_] jntid: i32,
     [dof_] parentid: i32, dof_treeid: i32,
     [dof_] Madr: i32],
	[]);

info_with_view!(Model, light,
	[[light_] mode: MjtCamLight [force],
	 [light_] r#type: MjtLightType [force],
	 [light_] castshadow: MjtBool,
	 [light_] bulbradius: f32,
	 [light_] intensity: f32,
	 [light_] range: f32,
	 [light_] active: MjtBool,
	 [light_] pos: MjtNum,
	 [light_] dir: MjtNum,
	 [light_] poscom0: MjtNum,
	 [light_] pos0: MjtNum,
	 [light_] dir0: MjtNum,
	 [light_] attenuation: f32,
	 [light_] cutoff: f32,
	 [light_] softness: f32,
	 [light_] exponent: f32,
	 [light_] ambient: f32,
	 [light_] diffuse: f32,
	 [light_] specular: f32],
	[[light_] bodyid: i32,
	 [light_] targetbodyid: i32,
	 [light_] texid: i32],
	[]);

info_with_view!(Model, material,
	[[mat_] texuniform: MjtBool,
	 [mat_] texrepeat: f32,
	 [mat_] emission: f32,
	 [mat_] specular: f32,
	 [mat_] shininess: f32,
	 [mat_] reflectance: f32,
	 [mat_] rgba: f32,
     [mat_] metallic: f32,
     [mat_] roughness: f32],
	[[mat_] texid: i32],
	[]);

info_with_view!(Model, mesh,
	[[mesh_] scale: MjtNum,
	 [mesh_] pos: MjtNum,
	 [mesh_] quat: MjtNum],
	[[mesh_] vertadr: i32,
	 [mesh_] vertnum: i32,
	 [mesh_] texcoordadr: i32,
	 [mesh_] faceadr: i32,
	 [mesh_] facenum: i32,
	 [mesh_] graphadr: i32,
	 [mesh_] extrema: i32,
	 [mesh_] normaladr: i32,
	 [mesh_] normalnum: i32,
	 [mesh_] texcoordnum: i32,
	 [mesh_] bvhadr: i32,
	 [mesh_] bvhnum: i32,
	 [mesh_] octadr: i32,
	 [mesh_] octnum: i32,
	 [mesh_] pathadr: i32,
	 [mesh_] polynum: i32,
	 [mesh_] polyadr: i32],
	[]);

info_with_view!(Model, numeric,
	[],
	[[numeric_] adr: i32,
	 [numeric_] size: i32],
	[[numeric_] data: MjtNum]);

info_with_view!(Model, pair,
	[[pair_] solref: MjtNum,
	 [pair_] solimp: MjtNum,
	 [pair_] margin: MjtNum,
	 [pair_] gap: MjtNum,
	 [pair_] adhesion: MjtNum,
	 [pair_] friction: MjtNum,
     [pair_] solreffriction: MjtNum,
	 [pair_] signature: i32],
	[[pair_] dim: i32,
	 [pair_] geom1: i32,
	 [pair_] geom2: i32],
	[]);

info_with_view!(Model, sensor,
	[[sensor_] cutoff: MjtNum,
	 [sensor_] noise: MjtNum,
	 [sensor_] delay: MjtNum,
     [sensor_] interval: MjtNum,
	 [sensor_] user: MjtNum,
	 [sensor_] datatype: MjtDataType [force],
	 [sensor_] needstage: MjtStage [force]],
	[[sensor_] intprm: i32,
	 [sensor_] r#type: MjtSensor [force],
	 [sensor_] objid: i32,
	 [sensor_] refid: i32,
	 [sensor_] objtype: MjtObj [force],
	 [sensor_] reftype: MjtObj [force],
	 [sensor_] dim: i32,
	 [sensor_] adr: i32,
	 [sensor_] history: i32,
	 [sensor_] historyadr: i32,
	 [sensor_] plugin: i32],
	[]);

info_with_view!(Model, site,
	[[site_] group: i32,
	 [site_] sameframe: MjtSameFrame [force],
	 [site_] size: MjtNum,
	 [site_] pos: MjtNum,
	 [site_] quat: MjtNum,
	 [site_] user: MjtNum,
	 [site_] rgba: f32,
	 [site_] r#type: MjtGeom [force]],
	[[site_] bodyid: i32,
	 [site_] matid: i32],
	[]);

info_with_view!(Model, skin,
	[[skin_] group: i32,
	 [skin_] rgba: f32,
	 [skin_] inflate: f32],
	[[skin_] matid: i32,
	 [skin_] vertadr: i32,
	 [skin_] vertnum: i32,
	 [skin_] texcoordadr: i32,
	 [skin_] faceadr: i32,
	 [skin_] facenum: i32,
	 [skin_] boneadr: i32,
	 [skin_] bonenum: i32,
	 [skin_] pathadr: i32],
	[]);

info_with_view!(Model, tendon,
	[[tendon_] group: i32,
	 [tendon_] limited: MjtBool, [tendon_] actfrclimited: MjtBool, [tendon_] width: MjtNum,
	 [tendon_] solref_lim: MjtNum, [tendon_] solimp_lim: MjtNum,
	 [tendon_] solref_fri: MjtNum, [tendon_] solimp_fri: MjtNum,
	 [tendon_] range: MjtNum, [tendon_] actfrcrange: MjtNum, [tendon_] margin: MjtNum,
	 [tendon_] stiffness: MjtNum,
	 [tendon_] stiffnesspoly: MjtNum,
	 [tendon_] damping: MjtNum,
	 [tendon_] dampingpoly: MjtNum,
	 [tendon_] armature: MjtNum,
	 [tendon_] frictionloss: MjtNum, [tendon_] lengthspring: MjtNum,
	 [tendon_] length0: MjtNum, [tendon_] invweight0: MjtNum,
	 [tendon_] user: MjtNum, [tendon_] rgba: f32,
	 [tendon_] treenum: i32],
	[[tendon_] matid: i32, [tendon_] actuatorid: i32, [tendon_] treeid: i32,
	 [tendon_] adr: i32, [tendon_] num: i32,
     [ten_] J_rownnz: i32, [ten_] J_rowadr: i32, [ten_] J_colind: i32],
	[]);

info_with_view!(Model, texture,
	[[tex_] colorspace: MjtColorSpace [force]],
	[[tex_] r#type: MjtTexture [force],
	 [tex_] height: i32,
	 [tex_] width: i32,
	 [tex_] nchannel: i32,
	 [tex_] adr: MjtSize,
	 [tex_] pathadr: i32],
	[[tex_] data: MjtByte]);

info_with_view!(Model, tuple,
	[[tuple_] objprm: MjtNum,
	 [tuple_] objtype: MjtObj [force]],
	[[tuple_] adr: i32,
	 [tuple_] size: i32,
	 [tuple_] objid: i32],
	[]);

info_with_view!(Model, key,
	[[key_] time: MjtNum,
	 [key_] qpos: MjtNum,
	 [key_] qvel: MjtNum,
	 [key_] act: MjtNum,
	 [key_] mpos: MjtNum,
	 [key_] mquat: MjtNum,
	 [key_] ctrl: MjtNum],
	[],
	[]);

#[cfg(test)]
#[expect(clippy::needless_range_loop,
         reason = "the loop indices drive FFI pointer arithmetic, ptr.add(i * stride + j)")]
mod tests {
    use crate::assert_relative_eq;

    use super::*;
    use std::fs;

    const EXAMPLE_MODEL: &str = stringify!(
    <mujoco>
        <worldbody>
            <light name="lamp_light1"
                mode="fixed" type="directional" castshadow="false" bulbradius="0.5" intensity="250"
                range="10" active="true" pos="0 0 0" dir="0 0 -1" attenuation="0.1 0.05 0.01"
                cutoff="60" exponent="2" ambient="0.1 0.1 0.25" diffuse="0.5 1 1" specular="1 1.5 1"/>

            <light name="lamp_light2"
                mode="fixed" type="spot" castshadow="true" bulbradius="0.2" intensity="500"
                range="10" active="true" pos="0 0 0" dir="0 0 -1" attenuation="0.1 0.05 0.01"
                cutoff="45" exponent="2" ambient="0.1 0.1 0.1" diffuse="1 1 1" specular="1 1 1"/>

            <camera name="cam1" fovy="50" resolution="100 200"/>

            <light ambient="0.2 0.2 0.2"/>
            <body name="ball">
                <geom name="green_sphere" pos=".2 .2 .2" size=".1" rgba="0 1 0 1"/>
                <joint name="ball" type="free" axis="1 1 1"/>
                <site name="touch" size="1" type="box"/>
            </body>

            <body name="ball1" pos="-.5 0 0">
                <geom size=".1" rgba="0 1 0 1" mass="1"/>
                <joint type="free"/>
                <site name="ball1" size=".1 .1 .1" pos="0 0 0" rgba="0 1 0 0.2" type="box"/>
                <site name="ball12" size=".1 .1 .1" pos="0 0 0" rgba="0 1 1 0.2" type="box"/>
                <site name="ball13" size=".1 .1 .1" pos="0 0 0" rgba="0 1 1 0.2" type="box"/>
            </body>

            <body name="ball2"  pos=".5 0 0">
                <geom name="ball2" size=".5" rgba="0 1 1 1" mass="1"/>
                <joint name="ball2" type="free"/>
                <site name="ball2" size=".1 .1 .1" pos="0 0 0" rgba="0 1 1 0.2" type="box"/>
                <site name="ball22" size="0.5 0.25 0.5" pos="5 1 3" rgba="1 2 3 1" type="box"/>
                <site name="ball23" size=".1 .1 .1" pos="0 0 0" rgba="0 1 1 0.2" type="box"/>
            </body>

            <geom name="floor" type="plane" size="10 10 1" euler="5 0 0"/>

            <body name="slider">
                <geom name="rod" type="cylinder" size="1 10 0" euler="90 0 0" pos="0 0 10"/>
                <joint name="rod" type="slide" axis="0 1 0" range="0 1"/>
            </body>

            <body name="ball3"  pos="0 0 5">
                <geom name="ball31" size=".5" rgba="0 1 1 1" mass="1"/>
                <joint type="slide"/>
            </body>

            <body name="ball32"  pos="0 0 -5">
                <geom name="ball32" size=".5" rgba="0 1 1 1" mass="1"/>
                <joint type="slide"/>
            </body>

            <body name="eq_body1" pos="0 0 0">
                <geom size="0.1"/>
            </body>
            <body name="eq_body2" pos="1 0 0">
                <geom size="0.1"/>
            </body>
            <body name="eq_body3" pos="0 0 0">
                <geom size="0.1"/>
            </body>
            <body name="eq_body4" pos="1 0 0">
                <geom size="0.1"/>
            </body>
        </worldbody>

        
        <equality>
            <connect name="eq1" body1="eq_body1" body2="eq_body2" anchor="15 0 10"/>
            <connect name="eq2" body1="eq_body2" body2="eq_body1" anchor="-5 0 10"/>
            <connect name="eq3" body1="eq_body3" body2="eq_body4" anchor="0 5 0"/>
            <connect name="eq4" body1="eq_body4" body2="eq_body3" anchor="5 5 10"/>
        </equality>


        <actuator>
            <general name="slider" joint="rod" biastype="affine" ctrlrange="0 1" dynprm="1 2 3 4 5 6 7 8 9 10" gaintype="fixed"/>
            <general name="slider2" joint="ball2" biastype="affine" ctrlrange="0 1" dynprm="10 9 8 7 6 5 4 3 2 1" gaintype="fixed"/>
        </actuator>

        <sensor>
            <touch name="touch" site="touch"/>
        </sensor>

        <tendon>
            <spatial name="tendon1" limited="false" range="0 5" rgba="0 .5 2 3" width=".5">
                <site site="ball1"/>
                <site site="ball2"/>
            </spatial>
        </tendon>

        <tendon>
            <spatial name="tendon2" limited="true" range="0 1" rgba="0 .1 1 1" width=".005">
                <site site="ball1"/>
                <site site="ball2"/>
            </spatial>
        </tendon>

        <tendon>
            <spatial name="tendon3" limited="false" range="0 5" rgba=".5 .2 .4 .3" width=".25">
                <site site="ball1"/>
                <site site="ball2"/>
            </spatial>
        </tendon>

        <!-- Contact pair between the two geoms -->
        <contact>
            <pair name="geom_pair" geom1="ball31" geom2="ball32" condim="3" solref="0.02 1"
                solreffriction="0.01 0.5" solimp="0.0 0.95 0.001 0.5 2" margin="0.001" gap="0"
                friction="1.0 0.8 0.6 0.0 0.0">
            </pair>
        </contact>

        <!-- A keyframe with qpos/qvel/ctrl etc. -->
        <keyframe>
            <!-- adjust nq/nv/nu in <default> or body definitions to match
                lengths in your test constants -->
            <key name="pose0"
                time="0.0"
                qpos="1.1 1.2 1.3 1.1 0.2 0.3 0.1 1.2 0.3 1.1 0.2 1.3 0.1 1.2 0.3 1.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.0"
                qvel="0.5 5.0 5.0 0.0 1.0 0.0 0.0 5.0 0.0 5.0 1.0 5.0 0.0 1.0 5.0 0.0 1.0 0.0 0.0 1.0 0.0"
                ctrl="0.5 0.5"/>
            <key name="pose1"
                time="1.5"
                qpos="0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.3 0.1 0.2 0.0"
                qvel="0.0 1.0 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 1.0 0.0 0.0 1.0 0.0"
                ctrl="0.5 0.0"/>
        </keyframe>

        <custom>
            <tuple name="tuple_example">
                <!-- First entry: a body -->
                <element objtype="body" objname="ball2" prm="0.5"/>
                <!-- Second entry: a site -->
                <element objtype="site" objname="ball1" prm="1.0"/>
            </tuple>

            <!-- Numeric element with a single value -->
            <numeric name="gain_factor1" size="5" data="3.14159 0 0 0 3.14159"/>
            <numeric name="gain_factor2" size="3" data="1.25 5.5 10.0"/>
        </custom>

        <!-- Texture definition -->
        <asset>
            <texture name="wall_tex"
                type="2d"
                colorspace="sRGB"
                width="128"
                height="128"
                nchannel="3"
                builtin="flat"
                rgb1="0.6 0.6 0.6"
                rgb2="0.6 0.6 0.6"
                mark="none"/>

            <!-- Material definition -->
            <material name="wood_material"
                rgba="0.8 0.5 0.3 1"
                emission="0.1"
                specular="0.5"
                shininess="0.7"
                reflectance="0.2"
                metallic="0.3"
                roughness="0.4"
                texuniform="true"
                texrepeat="2 2"/>

            <!-- Material definition -->
            <material name="also_wood_material"
                rgba="0.8 0.5 0.3 1"
                emission="0.1"
                specular="0.5"
                shininess="0.7"
                reflectance="0.2"
                metallic="0.3"
                roughness="0.5"
                texuniform="false"
                texrepeat="2 2"/>

            <hfield name="hf1" nrow="2" ncol="3" size="1 1 1 0.1"/>
            <hfield name="hf2" nrow="5" ncol="3" size="1 1 1 5.25"/>
            <hfield name="hf3" nrow="2" ncol="3" size="1 1 1 0.1"/>
        </asset>
    </mujoco>
);

    #[test]
    fn test_integrate_and_differentiate_pos() {
        const DT: MjtNum = 0.05;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        assert!(model.nq() > model.nv(), "the model must hold a quaternion joint");

        let qvel: Vec<MjtNum> = (0..model.nv()).map(|i| 0.1 * (i as MjtNum + 1.0)).collect();
        let qpos1 = model.qpos0().to_vec();
        let mut qpos2 = qpos1.clone();
        model.integrate_pos(&mut qpos2, &qvel, DT);
        assert_ne!(qpos1, qpos2, "integration must move the configuration");

        let recovered = model.differentiate_pos(DT, &qpos1, &qpos2);
        assert_eq!(recovered.len(), model.nv() as usize);
        for (got, expected) in recovered.iter().zip(&qvel) {
            assert_relative_eq!(*got, *expected, epsilon = 1e-9);
        }
    }

    #[test]
    fn test_differentiate_pos_rejects_bad_length() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let qpos = model.qpos0().to_vec();
        let short = &qpos[..qpos.len() - 1];

        assert!(matches!(
            model.try_differentiate_pos(0.1, short, &qpos),
            Err(MjModelError::LengthMismatch { name: "qpos1", .. })
        ));
        assert!(matches!(
            model.try_differentiate_pos(0.1, &qpos, short),
            Err(MjModelError::LengthMismatch { name: "qpos2", .. })
        ));
    }

    #[test]
    fn test_differentiate_pos_into_buffer_bounds() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let nv = model.nv() as usize;
        let qpos1 = model.qpos0().to_vec();
        let mut qpos2 = qpos1.clone();
        model.integrate_pos(&mut qpos2, &vec![0.1; nv], 1.0);

        let mut qvel = vec![MjtNum::NAN; nv + 2];
        model.differentiate_pos_into(1.0, &qpos1, &qpos2, &mut qvel);
        assert!(qvel[..nv].iter().all(|v| v.is_finite()), "every element below nv is written");
        assert!(qvel[nv..].iter().all(|v| v.is_nan()), "elements above nv keep their previous values");

        assert!(matches!(
            model.try_differentiate_pos_into(1.0, &qpos1, &qpos2, &mut vec![0 as MjtNum; nv - 1]),
            Err(MjModelError::BufferTooSmall { needed, available }) if needed == nv && available == nv - 1
        ));
    }

    #[test]
    fn test_normalize_quat() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let free_adr = model.jnt_qposadr()[0] as usize;
        assert_eq!(model.jnt_type()[0], MjtJoint::mjJNT_FREE);

        let mut qpos = model.qpos0().to_vec();
        qpos[free_adr + 3..free_adr + 7].copy_from_slice(&[2.0, 0.0, 0.0, 2.0]);
        model.normalize_quat(&mut qpos);

        let quat = &qpos[free_adr + 3..free_adr + 7];
        let norm = quat.iter().map(|q| q * q).sum::<MjtNum>().sqrt();
        assert_relative_eq!(norm, 1.0, epsilon = 1e-12);
        assert_relative_eq!(quat[0], 0.5_f64.sqrt(), epsilon = 1e-12);
        assert_relative_eq!(quat[3], 0.5_f64.sqrt(), epsilon = 1e-12);
    }

    /// Tests if the model can be loaded and then saved.
    #[test]
    fn test_model_load_save() {
        const MODEL_SAVE_XML_PATH: &str = "./__TMP_MODEL1.xml";
        const MODEL_INVALID_SAVE_XML_PATH: &str = "/some/non-existent/path/";

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        model.save_last_xml(MODEL_SAVE_XML_PATH).expect("could not save the model XML.");      
        fs::remove_file(MODEL_SAVE_XML_PATH).unwrap();

        // Try to get an error
        assert!(model.save_last_xml(MODEL_INVALID_SAVE_XML_PATH).is_err());
    }

    #[test]
    fn test_model_encode() {
        const PATH_MJB: &str = "./__TMP_MODEL_ENCODE.mjb";
        const PATH_XML: &str = "./__TMP_MODEL_ENCODE.xml";

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        model.encode(PATH_MJB, "").unwrap();
        model.encode_with_vfs(PATH_XML, "text/xml", &MjVfs::new()).unwrap();

        let encoded = MjModel::from_buffer(&fs::read(PATH_MJB).unwrap()).unwrap();
        // The XML encoder writes the spec of the last XML load, which a parallel test may replace,
        // so only the MJB round trip is compared against `model`.
        let reloaded = MjModel::from_xml(PATH_XML);
        fs::remove_file(PATH_MJB).unwrap();
        fs::remove_file(PATH_XML).unwrap();

        assert!(model.is_compatible_with_model(&encoded));
        reloaded.unwrap();

        assert!(model.encode("/some/non-existent/path/model.xml", "").is_err());
    }

    #[test]
    fn test_actuator_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let actuator_model_info = model.actuator("slider").unwrap();
        let view = actuator_model_info.view(&model);

        /* Test read */
        assert_eq!(view.biastype[0], MjtBias::mjBIAS_AFFINE);
        assert_eq!(&view.ctrlrange[..], [0.0, 1.0]);
        assert!(view.ctrllimited[0]);
        assert!(!view.forcelimited[0]);
        assert_eq!(view.trntype[0], MjtTrn::mjTRN_JOINT);
        assert_eq!(view.gaintype[0], MjtGain::mjGAIN_FIXED);

        /* Test direct array slice correspondance */
        assert_eq!(view.dynprm[..], model.actuator_dynprm()[actuator_model_info.id]);

        /* Test write */
        let mut view_mut = actuator_model_info.view_mut(&mut model);
        view_mut.biastype[0] = MjtBias::mjBIAS_USER;
        view_mut.delay[0] = 3.0;

        assert_eq!(view_mut.biastype[0], MjtBias::mjBIAS_USER);
        assert_eq!(view_mut.delay[0], 3.0);
        view_mut.zero();

        assert_eq!(view_mut.delay[0], 0.0);
        assert_eq!(view_mut.biastype[0], MjtBias::mjBIAS_NONE);
    }

    /// `light_softness` must expose the per-light `softness`, not one of the arrays that bracket
    /// it in `mjModel` (`light_cutoff` before it, `light_exponent` after it).
    #[test]
    fn test_light_softness() {
        const XML: &str = stringify!(
            <mujoco>
                <worldbody>
                    <light name="spot1" type="spot" cutoff="45" softness="0.25" exponent="2"/>
                    <light name="spot2" type="spot" cutoff="60" softness="0.75" exponent="3"/>
                </worldbody>
            </mujoco>
        );
        let model = MjModel::from_xml_string(XML).unwrap();
        assert_eq!(model.light_softness(), [0.25, 0.75]);

        let info = model.light("spot2").unwrap();
        assert_eq!(info.view(&model).softness[0], 0.75);
    }

    #[test]
    fn test_sensor_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let sensor_model_info = model.sensor("touch").unwrap();
        let view = sensor_model_info.view(&model);
        
        /* Test read */
        assert_eq!(view.dim[0], 1);
        assert_eq!(view.objtype[0], MjtObj::mjOBJ_SITE);
        assert_eq!(view.noise[0], 0.0);
        assert_eq!(view.r#type[0], MjtSensor::mjSENS_TOUCH);

        /* Test write */
        let mut view_mut = sensor_model_info.view_mut(&mut model);
        view_mut.noise[0] = 1.0;
        assert_eq!(view_mut.noise[0], 1.0);
    }

    #[test]
    fn test_tendon_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let tendon_model_info = model.tendon("tendon2").unwrap();
        let view = tendon_model_info.view(&model);
        
        /* Test read */
        assert_eq!(&view.range[..], [0.0, 1.0]);
        assert!(view.limited[0]);
        assert_eq!(view.width[0], 0.005);

        /* Test alignment with the array slice */
        let tendon_id = tendon_model_info.id;
        assert_eq!(view.width[0], model.tendon_width()[tendon_id]);
        assert_eq!(*view.range, model.tendon_range()[tendon_id]);
        assert_eq!(view.limited[0], model.tendon_limited()[tendon_id]);

        /* Test write */
        let mut view_mut = tendon_model_info.view_mut(&mut model);
        view_mut.frictionloss[0] = 5e-2;
        assert_eq!(view_mut.frictionloss[0], 5e-2);
    }

    #[test]
    fn test_joint_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let model_info = model.joint("rod").unwrap();
        let view = model_info.view(&model);
        
        /* Test read */
        assert_eq!(view.r#type[0], MjtJoint::mjJNT_SLIDE);
        assert!(view.limited[0]);
        assert_eq!(&view.axis[..], [0.0, 1.0 , 0.0]);
        assert!(!view.dof_bodyid.is_empty());
        assert!(!view.dof_treeid.is_empty());

        let dof_start = model.jnt_dofadr()[model_info.id] as usize;
        assert_eq!(view.dof_bodyid[0], model.dof_bodyid()[dof_start]);
        assert_eq!(view.dof_treeid[0], model.dof_treeid()[dof_start]);

        // Also validate mapping for a multi-DOF joint.
        let free_info = model.joint("ball2").unwrap();
        let free_view = free_info.view(&model);
        assert!(free_view.dof_bodyid.len() > 1);
        assert_eq!(free_view.dof_bodyid.len(), free_view.dof_treeid.len());

        let free_dof_start = model.jnt_dofadr()[free_info.id] as usize;
        let free_dof_end = free_dof_start + free_view.dof_bodyid.len();
        assert_eq!(&free_view.dof_bodyid[..], &model.dof_bodyid()[free_dof_start..free_dof_end]);
        assert_eq!(&free_view.dof_treeid[..], &model.dof_treeid()[free_dof_start..free_dof_end]);

        /* Test write */
        let mut view_mut = model_info.view_mut(&mut model);
        view_mut.axis.copy_from_slice(&[1.0, 0.0, 0.0]);
        assert_eq!(&view_mut.axis[..], [1.0, 0.0 , 0.0]);
    }

    #[test]
    fn test_geom_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let model_info = model.geom("ball2").unwrap();
        let view = model_info.view(&model);
        
        /* Test read */
        assert_eq!(view.r#type[0], MjtGeom::mjGEOM_SPHERE);
        assert_eq!(view.size[0], 0.5);

        /* Test write */
        let mut view_mut = model_info.view_mut(&mut model);
        view_mut.size[0] = 1.0;
        assert_eq!(view_mut.size[0], 1.0);
    }

    #[test]
    fn test_body_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let model_info = model.body("ball2").unwrap();
        let view = model_info.view(&model);
        
        /* Test read */
        assert_eq!(view.pos[0], 0.5);

        /* Test alignment with slice */
        let body_id = model_info.id;
        assert_eq!(model.body_sameframe()[body_id], view.sameframe[0]);

        /* Test write */
        let mut view_mut = model_info.view_mut(&mut model);
        view_mut.pos[0] = 1.0;
        assert_eq!(view_mut.pos[0], 1.0);
    }


    /// XML of a hinge body with one motor; `{extra}` adds a size or actuator difference that
    /// `mjCModel::Signature` does not hash.
    const COMPAT_MODEL: &str = "<mujoco>{extra}\
<worldbody><body name='b1'><joint name='j' type='hinge'/><geom size='0.1'/></body></worldbody>\
<actuator>{actuator}</actuator></mujoco>";

    fn compat_model(extra: &str, actuator: &str) -> MjModel {
        let xml = COMPAT_MODEL.replace("{extra}", extra).replace("{actuator}", actuator);
        MjModel::from_xml_string(&xml).unwrap()
    }

    #[test]
    fn test_is_compatible_with_model_rejects_unpinned_size() {
        let plain = compat_model("", "<motor joint='j'/>");

        // nuserdata sizes mjData::userdata; the signature does not hash it.
        let userdata = compat_model("<size nuserdata='2000'/>", "<motor joint='j'/>");
        assert_eq!(plain.signature(), userdata.signature(), "the pair must share a signature");
        assert_ne!(plain.nuserdata(), userdata.nuserdata());
        assert!(!plain.is_compatible_with_model(&userdata));

        // na sizes mjData::act; the actuator tag carries no dynamics type.
        let stateful = compat_model("", "<general joint='j' dyntype='integrator'/>");
        assert_eq!(plain.signature(), stateful.signature(), "the pair must share a signature");
        assert_ne!(plain.na(), stateful.na());
        assert!(!plain.is_compatible_with_model(&stateful));
    }

    #[test]
    fn test_is_compatible_with_model_rejects_a_different_arena_size() {
        let plain = compat_model("", "<motor joint='j'/>");

        // mjData inherits narena from the model, and mj_copyDataVisual raises mjERROR on a
        // mismatch, which ends the process.
        let small = compat_model("<size memory='4M'/>", "<motor joint='j'/>");
        assert_eq!(plain.signature(), small.signature(), "the pair must share a signature");
        assert_ne!(plain.narena(), small.narena());
        assert!(!plain.is_compatible_with_model(&small));
    }

    #[test]
    fn test_is_compatible_with_model_rejects_a_different_mesh_split() {
        const TET: &str = "0 0 0  1 0 0  0 1 0  0 0 1";
        const CUBE: &str = "0 0 0  1 0 0  1 1 0  0 1 0  0 0 1  1 0 1  1 1 1  0 1 1";
        let mesh_model = |first: &str, second: &str| MjModel::from_xml_string(&format!(
            "<mujoco><asset><mesh name='m1' vertex='{first}'/><mesh name='m2' vertex='{second}'/>\
             </asset><worldbody><body name='b'><joint name='j' type='hinge'/>\
             <geom type='mesh' mesh='m1'/><geom type='mesh' mesh='m2'/></body></worldbody></mujoco>"
        )).unwrap();

        let model = mesh_model(TET, CUBE);
        let swapped = mesh_model(CUBE, TET);
        assert_eq!(model.signature(), swapped.signature(), "the pair must share a signature");
        assert_eq!(model.nmeshvert(), swapped.nmeshvert(), "the vertex totals must agree");
        assert_ne!(model.mesh_vertadr(), swapped.mesh_vertadr());
        assert!(!model.is_compatible_with_model(&swapped));
        // An `Info` gate compares layouts alone, so the layout must carry the split.
        assert_ne!(model.layout(), swapped.layout());
        assert!(model.is_compatible_with_model(&mesh_model(TET, CUBE)));
    }

    #[test]
    fn test_is_compatible_with_model_accepts_a_renamed_element() {
        const LONG_NAME: &str = "name='a_body_name_long_enough_to_cross_the_model_buffer_padding_boundary'";
        let model = compat_model("", "<motor joint='j'/>");
        let renamed = MjModel::from_xml_string(
            &COMPAT_MODEL.replace("{extra}", "").replace("{actuator}", "<motor joint='j'/>")
                         .replace("name='b1'", LONG_NAME)
        ).unwrap();

        assert_eq!(model.signature(), renamed.signature(), "the pair must share a signature");
        assert_ne!(model.nbuffer(), renamed.nbuffer(), "the rename must move nbuffer");
        assert_eq!(model.narena(), renamed.narena(), "no mjData buffer may follow the name");
        assert!(model.is_compatible_with_model(&renamed));
    }

    /// A slide joint and a hinge joint share their `qpos` and `dof` footprint, so every address
    /// table and every size agrees. Only the joint type separates the pair, and it changes what
    /// the state means.
    #[test]
    fn test_is_compatible_with_model_rejects_a_joint_type_change() {
        let joint_model = |kind: &str| MjModel::from_xml_string(&format!(
            "<mujoco><worldbody><body><joint type='{kind}'/><geom size='0.1'/></body>\
             </worldbody></mujoco>"
        )).unwrap();

        let slide = joint_model("slide");
        let hinge = joint_model("hinge");
        assert_eq!(slide.signature(), hinge.signature(), "the pair must share a signature");
        assert_eq!(slide.nq(), hinge.nq(), "the qpos totals must agree");
        assert_eq!(slide.nv(), hinge.nv(), "the dof totals must agree");
        assert_eq!(slide.jnt_qposadr(), hinge.jnt_qposadr());
        assert_eq!(slide.jnt_dofadr(), hinge.jnt_dofadr());
        assert!(!slide.is_compatible_with_model(&hinge));
    }

    /// The kinematic tree is the one structure that `mjCModel::Signature` carried alone, so the
    /// gate must reject a re-parented body now that it ignores the signature.
    #[test]
    fn test_is_compatible_with_model_rejects_a_different_body_tree() {
        const INNER: &str = "<body name='b2' pos='0.1 0 0'><joint type='hinge'/>\
                             <geom size='0.05'/></body>";
        let nested = MjModel::from_xml_string(&format!(
            "<mujoco><worldbody><body name='b1'><joint type='hinge'/><geom size='0.1'/>\
             {INNER}</body></worldbody></mujoco>"
        )).unwrap();
        let siblings = MjModel::from_xml_string(&format!(
            "<mujoco><worldbody><body name='b1'><joint type='hinge'/><geom size='0.1'/></body>\
             {INNER}</worldbody></mujoco>"
        )).unwrap();

        assert_eq!(nested.nbody(), siblings.nbody(), "the body counts must agree");
        assert_eq!(nested.nq(), siblings.nq(), "the qpos totals must agree");
        assert_eq!(nested.njnt(), siblings.njnt(), "the joint counts must agree");
        assert_ne!(nested.body_parentid(), siblings.body_parentid());
        // The signature also separates this pair, so test the table that must carry the tree.
        assert_ne!(nested.element_split_tables(), siblings.element_split_tables());
        assert!(!nested.is_compatible_with_model(&siblings));
    }

    #[test]
    fn test_is_compatible_with_model_rejects_a_different_sensor_split() {
        let sensor_model = |first: u32, second: u32| MjModel::from_xml_string(&format!(
            "<mujoco><worldbody><body name='b1'><joint name='j' type='hinge'/><geom size='0.1'/>\
             </body></worldbody><sensor><user name='u1' dim='{first}' objtype='body' objname='b1'/>\
             <user name='u2' dim='{second}' objtype='body' objname='b1'/></sensor></mujoco>"
        )).unwrap();

        let model = sensor_model(3, 1);
        let swapped = sensor_model(1, 3);
        assert_eq!(model.signature(), swapped.signature(), "the pair must share a signature");
        assert_eq!(model.nsensordata(), swapped.nsensordata(), "the data totals must agree");
        assert_ne!(model.sensor_adr(), swapped.sensor_adr());
        assert!(!model.is_compatible_with_model(&swapped));
        assert!(model.is_compatible_with_model(&sensor_model(3, 1)));
    }

    /// A view gate compares the layout alone, so the per-flex split must reach the layout: a
    /// contact holds a flex element index that C resolves through the per-flex tables.
    #[test]
    fn test_layout_rejects_a_different_flex_split() {
        let flex = |name: &str, bodies: &str, nvert: usize, element: &str| format!(
            "<flex name='{name}' dim='1' body='{bodies}' vertex='{}' element='{element}'>\
             <edge damping='1'/></flex>",
            "0 0 0 ".repeat(nvert)
        );
        let flex_model = |first: String, second: String| MjModel::from_xml_string(&format!(
            "<mujoco><worldbody>\
             <body name='v0'><freejoint/><geom size='0.01'/></body>\
             <body name='v1' pos='0.1 0 0'><freejoint/><geom size='0.01'/></body>\
             <body name='v2' pos='0.2 0 0'><freejoint/><geom size='0.01'/></body>\
             <body name='v3' pos='0.3 0 0'><freejoint/><geom size='0.01'/></body>\
             <body name='v4' pos='0.4 0 0'><freejoint/><geom size='0.01'/></body>\
             </worldbody><deformable>{first}{second}</deformable></mujoco>"
        )).unwrap();

        // The same five vertices and three elements, divided the other way round between f1 and f2.
        let model = flex_model(flex("f1", "v0 v1 v2", 3, "0 1 1 2"), flex("f2", "v3 v4", 2, "0 1"));
        let swapped = flex_model(flex("f1", "v0 v1", 2, "0 1"), flex("f2", "v2 v3 v4", 3, "0 1 1 2"));
        assert_eq!(model.signature(), swapped.signature(), "the pair must share a signature");
        assert_eq!(model.nflexvert(), swapped.nflexvert(), "the vertex totals must agree");
        assert_ne!(model.flex_vertnum(), swapped.flex_vertnum());
        assert!(!model.is_compatible_with_model(&swapped));
        assert_ne!(model.layout(), swapped.layout());
    }

    /// An asset copy overrides the asset data and reaches no `mjData` buffer, so it accepts a
    /// model that only sizes its data differently. A moved asset it still rejects.
    #[test]
    fn test_is_asset_compatible_with_model_ignores_the_data_sizes() {
        const TET: &str = "0 0 0  1 0 0  0 1 0  0 0 1";
        const CUBE: &str = "0 0 0  1 0 0  1 1 0  0 1 0  0 0 1  1 0 1  1 1 1  0 1 1";
        let asset_model = |extra: &str, first: &str, second: &str| MjModel::from_xml_string(&format!(
            "<mujoco>{extra}<asset><mesh name='m1' vertex='{first}'/><mesh name='m2' vertex='{second}'/>\
             </asset><worldbody><body name='b'><joint name='j' type='hinge'/>\
             <geom type='mesh' mesh='m1'/><geom type='mesh' mesh='m2'/></body></worldbody></mujoco>"
        )).unwrap();

        let model = asset_model("", TET, CUBE);
        let more_userdata = asset_model("<size nuserdata='2000'/>", TET, CUBE);
        assert!(!model.is_compatible_with_model(&more_userdata), "the mjData buffers differ");
        assert!(model.is_asset_compatible_with_model(&more_userdata));

        // The same total, split the other way round: the copy would write the neighbouring mesh.
        let swapped = asset_model("", CUBE, TET);
        assert_eq!(model.nmeshvert(), swapped.nmeshvert(), "the vertex totals must agree");
        assert!(!model.is_asset_compatible_with_model(&swapped));

        // A sensor moves no asset, so the asset test must read the asset tables alone.
        let sensor = asset_model("<sensor><user dim='4' objtype='body' objname='b'/></sensor>", TET, CUBE);
        assert!(!model.is_compatible_with_model(&sensor), "the element tables differ");
        assert!(model.is_asset_compatible_with_model(&sensor));
    }

    /// `mjr_makeContext` records `tex_type` in the `mjrContext` and `mjr_uploadTexture` binds
    /// `GL_TEXTURE_2D` or `GL_TEXTURE_CUBE_MAP` by it, so an upload that crosses the two kinds
    /// leaves the recorded kind disagreeing with the texture object. The compiler gives a cube
    /// texture `height = 6 * width`, which a 2D texture may also carry, so the sizes alone do not
    /// separate the pair.
    #[test]
    fn test_is_asset_compatible_with_model_rejects_a_different_texture_kind() {
        let textured = |kind: &str, width: u32, height: u32| MjModel::from_xml_string(&format!(
            "<mujoco><asset><texture name='t' type='{kind}' builtin='flat' width='{width}' \
             height='{height}' rgb1='1 1 1'/><material name='m' texture='t'/></asset>\
             <worldbody><geom size='0.1' material='m'/></worldbody></mujoco>"
        )).unwrap();

        let flat = textured("2d", 8, 48);
        let cube = textured("cube", 8, 8);
        assert_eq!(flat.tex_width(), cube.tex_width(), "the widths must agree");
        assert_eq!(flat.tex_height(), cube.tex_height(), "the compiler gives the cube 6 * width");
        assert_eq!(flat.tex_nchannel(), cube.tex_nchannel(), "the channel counts must agree");
        assert_eq!(flat.ntexdata(), cube.ntexdata(), "the pair holds the same number of bytes");
        assert_ne!(flat.tex_type(), cube.tex_type());

        assert!(!flat.is_asset_compatible_with_model(&cube));
        assert!(!flat.is_compatible_with_model(&cube));
        assert!(flat.is_asset_compatible_with_model(&textured("2d", 8, 48)));
    }

    /// [`MjModelLayout`] carries no size that a count table already determines, so a compatible
    /// pair keeps every size below equal only while the identity beside it holds. A MuJoCo release
    /// that adds a padding term, an alignment term or an extra row to one of them would let the
    /// gate accept a model whose `mjData` buffers differ, or whose joints keep their state
    /// elsewhere.
    #[test]
    fn test_every_dropped_size_follows_from_a_count_table() {
        let model = MjModel::from_xml_string(
            "<mujoco><asset>\
             <texture name='t1' type='2d' builtin='checker' width='17' height='23' rgb1='1 0 0' rgb2='0 1 0'/>\
             <texture name='t2' type='cube' builtin='flat' width='8' height='8' rgb1='1 1 1'/>\
             <texture name='t3' type='2d' builtin='flat' width='4' height='6' nchannel='4' rgb1='1 1 1'/>\
             <material name='mat' texture='t1'/>\
             <hfield name='hf' nrow='7' ncol='11' size='1 1 1 0.1'/>\
             <mesh name='ms' vertex='0 0 0  1 0 0  0 1 0  0 0 1' texcoord='0 0  1 0  0 1  1 1'/>\
             </asset><worldbody>\
             <geom type='hfield' hfield='hf'/>\
             <body name='free'><freejoint/><geom size='0.1' type='mesh' mesh='ms' material='mat'/>\
             <site name='s1'/>\
             <body name='ball' pos='0 0 0.2'><joint name='jb' type='ball'/><geom size='0.1'/>\
             <body name='slide' pos='0 0 0.2'><joint name='js' type='slide'/><geom size='0.1'/>\
             <site name='s2'/><joint name='jh' type='hinge'/></body></body></body>\
             <body name='v0'><freejoint/><geom size='0.01'/></body>\
             <body name='v1' pos='0.1 0 0'><freejoint/><geom size='0.01'/></body>\
             <body name='v2' pos='0.2 0 0'><freejoint/><geom size='0.01'/></body>\
             </worldbody>\
             <deformable><flex name='f1' dim='1' body='v0 v1 v2' vertex='0 0 0 0 0 0 0 0 0' element='0 1 1 2'>\
             <edge damping='1'/></flex>\
             </deformable>\
             <tendon><spatial name='td'><site site='s1'/><site site='s2'/></spatial>\
             <fixed name='tf'><joint joint='js' coef='1'/><joint joint='jh' coef='2'/></fixed></tendon>\
             <actuator><motor joint='jh'/><position joint='js' kp='3'/>\
             <general joint='jh' dyntype='integrator'/><general joint='js' dyntype='filter' dynprm='0.1'/>\
             <general tendon='tf' dyntype='filterexact' dynprm='0.1'/>\
             <orientation site='s2' refsite='s1' kp='1' input='expmap'/>\
             <orientation site='s2' refsite='s1' kp='1' input='quat'/>\
             <pid joint='jh' kp='1' kv='1' input='pos vel'/></actuator>\
             <sensor><framepos objtype='site' objname='s1'/><framequat objtype='site' objname='s1'/>\
             <jointpos joint='jh'/><accelerometer site='s2'/><tendonpos tendon='td'/>\
             <user objtype='site' objname='s2' dim='5' needstage='vel'/></sensor></mujoco>"
        ).unwrap();

        let sum = |table: &[i32]| table.iter().map(|&n| i64::from(n)).sum::<MjtSize>();
        let product = |first: &[i32], second: &[i32]| first.iter().zip(second)
            .map(|(&a, &b)| i64::from(a) * i64::from(b)).sum::<MjtSize>();

        // Every joint type appears above, so a wrong footprint for any one of them fails here.
        let qpos = |joint: &MjtJoint| match joint {
            MjtJoint::mjJNT_FREE => 7, MjtJoint::mjJNT_BALL => 4, _ => 1,
        };
        let dof = |joint: &MjtJoint| match joint {
            MjtJoint::mjJNT_FREE => 6, MjtJoint::mjJNT_BALL => 3, _ => 1,
        };
        assert_eq!(model.nq(), model.jnt_type().iter().map(qpos).sum::<MjtSize>());
        assert_eq!(model.nv(), model.jnt_type().iter().map(dof).sum::<MjtSize>());

        // Both joint address tables left the layout as well, because each one is the running
        // prefix sum of the same footprints, in joint id order and with no gap.
        let (mut qpos_adr, mut dof_adr) = (0, 0);
        for (id, joint) in model.jnt_type().iter().enumerate() {
            assert_eq!(i64::from(model.jnt_qposadr()[id]), qpos_adr, "joint {id}");
            assert_eq!(i64::from(model.jnt_dofadr()[id]), dof_adr, "joint {id}");
            qpos_adr += qpos(joint);
            dof_adr += dof(joint);
        }

        assert_eq!(model.nsensordata(), sum(model.sensor_dim()));
        assert_eq!(model.na(), sum(model.actuator_actnum()));
        assert_eq!(model.nu(), sum(model.actuator_ctrlnum()));
        assert_eq!(model.nout(), sum(model.actuator_outnum()));
        assert_eq!(model.n_jten(), sum(model.ten_j_rownnz()));
        assert_eq!(model.nflexvert(), sum(model.flex_vertnum()));
        assert_eq!(model.nflexelem(), sum(model.flex_elemnum()));

        assert_eq!(model.nmeshvert(), sum(model.mesh_vertnum()));
        assert_eq!(model.nmeshnormal(), sum(model.mesh_normalnum()));
        assert_eq!(model.nmeshtexcoord(), sum(model.mesh_texcoordnum()));
        assert_eq!(model.nmeshface(), sum(model.mesh_facenum()));
        assert_eq!(model.nhfielddata(), product(model.hfield_nrow(), model.hfield_ncol()));
        assert_eq!(model.ntexdata(), model.tex_width().iter().zip(model.tex_height())
            .zip(model.tex_nchannel())
            .map(|((&w, &h), &c)| i64::from(w) * i64::from(h) * i64::from(c)).sum::<MjtSize>());

        // An empty table satisfies every assertion above, so hold the model to its content.
        assert!(model.na() > 0 && model.nu() > 0 && model.nout() > 0);
        assert!(model.nsensordata() > 6 && model.n_jten() > 0);
        assert!(model.nflexvert() > 0 && model.nflexelem() > 0 && model.nmeshvert() > 0);
        assert_eq!(model.nhfielddata(), 77, "the heightfield must survive the compiler");
        assert!(model.ntexdata() > 0 && model.nmeshtexcoord() > 0);
        // A one-control actuator and a three-channel texture would hide a per-element term, so
        // hold the model to the multi-control and the multi-channel case as well.
        assert!(model.actuator_ctrlnum().contains(&4) && model.actuator_outnum().contains(&3));
        assert!(model.tex_nchannel().contains(&3) && model.tex_nchannel().contains(&4));
    }

    #[test]
    fn test_is_compatible_with_model_accepts_parameter_change() {
        let light = compat_model("", "<motor joint='j' gear='1'/>");
        let heavy = compat_model("", "<motor joint='j' gear='7'/>");
        assert!(light.is_compatible_with_model(&heavy));
        assert!(light.is_compatible_with_model(&light));
    }

    #[test]
    fn test_try_view_model_signature_mismatch() {
        let model1 = MjModel::from_xml_string("<mujoco><worldbody><body name='b1'><joint type='free'/><geom size='0.1'/></body></worldbody></mujoco>").unwrap();
        let mut model2 = MjModel::from_xml_string("<mujoco><worldbody><body name='b1'><joint type='free'/><geom size='0.1'/></body><body name='extra'/></worldbody></mujoco>").unwrap();

        let body_info = model1.body("b1").unwrap();

        let err = body_info.try_view(&model2).unwrap_err();
        match err {
            MjModelError::IncompatibleModel { source, destination } => {
                assert_eq!(source, model1.signature());
                assert_eq!(destination, model2.signature());
            }
            other => panic!("expected IncompatibleModel, got {other:?}"),
        }

        let err = body_info.try_view_mut(&mut model2).unwrap_err();
        match err {
            MjModelError::IncompatibleModel { source, destination } => {
                assert_eq!(source, model1.signature());
                assert_eq!(destination, model2.signature());
            }
            other => panic!("expected IncompatibleModel, got {other:?}"),
        }
    }

    #[test]
    #[should_panic(expected = "the model is not compatible")]
    fn test_view_mut_model_signature_mismatch_panics() {
        let model1 = MjModel::from_xml_string("<mujoco><worldbody><body name='b1'><joint type='free'/><geom size='0.1'/></body></worldbody></mujoco>").unwrap();
        let mut model2 = MjModel::from_xml_string("<mujoco><worldbody><body name='b1'><joint type='free'/><geom size='0.1'/></body><body name='extra'/></worldbody></mujoco>").unwrap();

        let body_info = model1.body("b1").unwrap();
        let _view = body_info.view_mut(&mut model2);
    }


    #[test]
    fn test_camera_model_view() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let model_info = model.camera("cam1").unwrap();
        let view = model_info.view(&model);

        /* Test read */
        assert_eq!(&view.resolution[..], [100, 200]);
        assert_eq!(view.fovy[0], 50.0);

        /* Test write */
        let mut view_mut = model_info.view_mut(&mut model);
        view_mut.fovy[0] = 60.0;
        assert_eq!(view_mut.fovy[0], 60.0);
    }

    #[test]
    fn test_id_2name_valid() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");

        // Body with id=1 should exist ("ball")
        let name = model.id_to_name(MjtObj::mjOBJ_BODY, 1);
        assert_eq!(name, Some("ball"));
    }

    #[test]
    fn test_model_prints() {
        const TMP_FILE: &str = "tmpprint.txt";
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        assert!(model.print(TMP_FILE).is_ok());
        fs::remove_file(TMP_FILE).unwrap();

        assert!(model.print_formatted(TMP_FILE, "%.2f").is_ok());
        fs::remove_file(TMP_FILE).unwrap();
    }

    #[test]
    fn test_id_2name_invalid() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");

        // Invalid id should return None
        let name = model.id_to_name(MjtObj::mjOBJ_BODY, 9999);
        assert_eq!(name, None);
    }

    #[test]
    fn test_totalmass_set_and_get() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");

        let mass_before = model.totalmass();
        model.set_totalmass(5.0);
        let mass_after = model.totalmass();

        assert_relative_eq!(mass_after, 5.0, epsilon = 1e-9);
        assert_ne!(mass_before, mass_after);
    }

    /// Tests if copying the model works without any memory problems.
    #[test]
    fn test_copy_model() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let _cloned = model.clone();
    }

    #[test]
    fn test_model_save() {
        const MODEL_SAVE_PATH: &str = "./__TMP_MODEL2.mjb";
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        model.save_to_file(MODEL_SAVE_PATH).unwrap();

        let saved_data = fs::read(MODEL_SAVE_PATH).unwrap();
        let mut data = vec![0; saved_data.len()];
        model.save_to_buffer(&mut data).unwrap();

        assert_eq!(saved_data, data);
        fs::remove_file(MODEL_SAVE_PATH).unwrap();

        /* Test virtual file system load */
        let model = MjModel::from_buffer(&saved_data).unwrap();
        assert!(model.light("lamp_light2").is_some());
        assert!(model.light("lamp_light-xyz").is_none());
    }

    #[test]
    fn test_model_from_mjb() {
        const MODEL_SAVE_PATH: &str = "./__TMP_MODEL3.mjb";
        const MODEL_VFS_PATH: &str = "__TMP_MODEL3_VFS.mjb";

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        model.save_to_file(MODEL_SAVE_PATH).unwrap();

        let loaded = MjModel::from_mjb(MODEL_SAVE_PATH).unwrap();
        assert!(model.is_compatible_with_model(&loaded));
        assert!(loaded.light("lamp_light2").is_some());

        /* Test virtual file system load */
        let mut vfs = MjVfs::new();
        vfs.add_from_buffer(MODEL_VFS_PATH, &fs::read(MODEL_SAVE_PATH).unwrap()).unwrap();
        // The MJB now exists on the VFS only, so a load that ignores the VFS finds no file.
        fs::remove_file(MODEL_SAVE_PATH).unwrap();

        let loaded_vfs = MjModel::from_mjb_vfs(MODEL_VFS_PATH, &vfs).unwrap();
        assert!(model.is_compatible_with_model(&loaded_vfs));
        assert!(loaded_vfs.light("lamp_light2").is_some());

        assert!(MjModel::from_mjb(MODEL_SAVE_PATH).is_err());
    }

    #[test]
    fn test_site_view() {
        // <site name="ball22" size="0.5 0.25 0.5" pos="5 1 3" rgba="1 2 3 1" type="box"/>
        const BODY_NAME: &str = "ball2";
        const SITE_NAME: &str = "ball22";
        const SITE_SIZE: [f64; 3] = [0.5, 0.25, 0.5];
        const SITE_POS: [f64; 3] = [5.0, 1.0, 3.0];
        const SITE_RGBA: [f32; 4] = [1.0, 2.0, 3.0, 1.0];
        const SITE_TYPE: MjtGeom = MjtGeom::mjGEOM_BOX;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("unable to load the model.");
        let info_ball = model.body(BODY_NAME).unwrap();
        let info_site = model.site(SITE_NAME).unwrap();
        let view_site = info_site.view(&model);

        /* Check if all the attributes given match */
        assert_eq!(info_site.name, SITE_NAME);
        assert_eq!(view_site.size[..], SITE_SIZE);
        assert_eq!(view_site.pos[..], SITE_POS);
        assert_eq!(view_site.rgba[..], SITE_RGBA);
        assert_eq!(view_site.r#type[0], SITE_TYPE);

        assert_eq!(view_site.bodyid[0] as usize, info_ball.id)
    }

    #[test]
    fn test_pair_view() {
        const PAIR_NAME: &str = "geom_pair";
        const DIM: i32 = 3;
        const GEOM1_NAME: &str = "ball31";
        const GEOM2_NAME: &str = "ball32";
        const SOLREF: [f64; mjNREF as usize] = [0.02, 1.0];
        const SOLREFFRICTION: [f64; mjNREF as usize] = [0.01, 0.5];
        const SOLIMP: [f64; mjNIMP as usize] = [0., 0.95, 0.001, 0.5, 2.0];
        const MARGIN: f64 = 0.001;
        const GAP: f64 = 0.0;
        const FRICTION: [f64; 5] = [1.0, 0.8, 0.6, 0.0, 0.0];

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_pair = model.pair(PAIR_NAME).unwrap();
        let view_pair = info_pair.view(&model);

        let geom1_info = model.geom(GEOM1_NAME).unwrap();
        let geom2_info = model.geom(GEOM2_NAME).unwrap();

        // signature =  body1 << 16 + body2 according to MuJoCo's documentation.
        let signature = ((geom1_info.view(&model).bodyid[0] as u32) << 16) + geom2_info.view(&model).bodyid[0] as u32;

        assert_eq!(view_pair.dim[0], DIM);
        assert_eq!(view_pair.geom1[0] as usize, geom1_info.id);
        assert_eq!(view_pair.geom2[0] as usize, geom2_info.id);
        assert_eq!(view_pair.signature[0] as u32, signature);
        assert_eq!(view_pair.solref[..], SOLREF);
        assert_eq!(view_pair.solreffriction[..], SOLREFFRICTION);
        assert_eq!(view_pair.solimp[..], SOLIMP);
        assert_eq!(view_pair.margin[0], MARGIN);
        assert_eq!(view_pair.gap[0], GAP);
        assert_eq!(view_pair.friction[..], FRICTION);
    }

    #[test]
    fn test_key_view() {
        const KEY_NAME: &str = "pose1";
        const TIME: f64 = 1.5;
        const QVEL: &[f64] = &[0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0];
        const ACT: &[f64]  = &[];
        const CTRL: &[f64] = &[0.5, 0.0];

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_key = model.key(KEY_NAME).unwrap();
        let view_key = info_key.view(&model);

        assert_eq!(view_key.time[0], TIME);
        // Don't test qpos, as it does some magic angle conversions, making the tests fail.
        // If all the other succeed, assume qpos works too (as its the exact same logic).
        assert_eq!(&view_key.qvel[..model.ffi().nv as usize], QVEL);
        assert_eq!(&view_key.act[..model.ffi().na as usize], ACT);
        assert_eq!(&view_key.ctrl[..model.ffi().nu as usize], CTRL);

        let key_qvel = &model.key_qvel()[model.ffi().nv as usize..];
        assert_eq!(key_qvel, QVEL);

        let key_act = &model.key_act()[model.ffi().na as usize..];
        assert_eq!(key_act, ACT);

        let key_ctrl = &model.key_ctrl()[model.ffi().nu as usize..];
        assert_eq!(key_ctrl, CTRL);
    }

    #[test]
    fn test_tuple_view() {
        const TUPLE_NAME: &str = "tuple_example";
        const SIZE: i32 = 2;
        const OBJTYPE: &[MjtObj] = &[MjtObj::mjOBJ_BODY, MjtObj::mjOBJ_SITE];
        const OBJPRM: &[f64]  = &[0.5, 1.0];

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_tuple = model.tuple(TUPLE_NAME).unwrap();
        let view_tuple = info_tuple.view(&model);

        let objid = &[
            model.body("ball2").unwrap().id as i32,
            model.site("ball1").unwrap().id as i32,
        ];

        assert_eq!(view_tuple.size[0], SIZE);
        assert_eq!(&view_tuple.objtype[..SIZE as usize], OBJTYPE);
        assert_eq!(&view_tuple.objid[..SIZE as usize], objid);
        assert_eq!(&view_tuple.objprm[..SIZE as usize], OBJPRM);
    }

    #[test]
    fn test_texture_view() {
        const TEX_NAME: &str = "wall_tex";
        const TYPE: MjtTexture = MjtTexture::mjTEXTURE_2D;          // for example, 2 = 2D texture
        const COLORSPACE: MjtColorSpace = MjtColorSpace::mjCOLORSPACE_SRGB;    // e.g. RGB
        const HEIGHT: i32 = 128;
        const WIDTH: i32 = 128;
        const NCHANNEL: i32 = 3;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_tex = model.texture(TEX_NAME).unwrap();
        let view_tex = info_tex.view(&model);

        assert_eq!(view_tex.r#type[0], TYPE);
        assert_eq!(view_tex.colorspace[0], COLORSPACE);
        assert_eq!(view_tex.height[0], HEIGHT);
        assert_eq!(view_tex.width[0], WIDTH);
        assert_eq!(view_tex.nchannel[0], NCHANNEL);

        assert_eq!(view_tex.data.as_ref().unwrap().len(), (WIDTH * HEIGHT * NCHANNEL) as usize);
    }

    #[test]
    fn test_numeric_view() {
        const NUMERIC_NAME: &str = "gain_factor2";
        const SIZE: i32 = 3;
        const DATA: [f64; 3] = [1.25, 5.5, 10.0];

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_numeric = model.numeric(NUMERIC_NAME).unwrap();
        let view_numeric = info_numeric.view(&model);

        assert_eq!(view_numeric.size[0], SIZE);
        assert_eq!(&view_numeric.data.as_ref().unwrap()[..SIZE as usize], DATA);
    }

    #[test]
    fn test_material_view() {
        const MATERIAL_NAME: &str = "also_wood_material";

        const TEXUNIFORM: bool = false;
        const TEXREPEAT: [f32; 2] = [2.0, 2.0];
        const EMISSION: f32 = 0.1;
        const SPECULAR: f32 = 0.5;
        const SHININESS: f32 = 0.7;
        const REFLECTANCE: f32 = 0.2;
        const METALLIC: f32 = 0.3;
        const ROUGHNESS: f32 = 0.5;
        const RGBA: [f32; 4] = [0.8, 0.5, 0.3, 1.0];
        const TEXID: i32 = -1;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_material = model.material(MATERIAL_NAME).unwrap();
        let view_material = info_material.view(&model);

        assert_eq!(view_material.texuniform[0], TEXUNIFORM);
        assert_eq!(view_material.texrepeat[..], TEXREPEAT);
        assert_eq!(view_material.emission[0], EMISSION);
        assert_eq!(view_material.specular[0], SPECULAR);
        assert_eq!(view_material.shininess[0], SHININESS);
        assert_eq!(view_material.reflectance[0], REFLECTANCE);
        assert_eq!(view_material.metallic[0], METALLIC);
        assert_eq!(view_material.roughness[0], ROUGHNESS);
        assert_eq!(view_material.rgba[..], RGBA);
        assert_eq!(view_material.texid[0], TEXID);
    }

    #[test]
    fn test_light_view() {
        const LIGHT_NAME: &str = "lamp_light2";
        const MODE: MjtCamLight = MjtCamLight::mjCAMLIGHT_FIXED;
        const BODYID: usize = 0;       // lamp body id
        const TYPE: MjtLightType = MjtLightType::mjLIGHT_SPOT;           // spot light, adjust if mjLightType differs
        const CASTSHADOW: bool = true;
        const ACTIVE: bool = true;

        const POS: [MjtNum; 3] = [0.0, 0.0, 0.0];
        const DIR: [MjtNum; 3] = [0.0, 0.0, -1.0];
        const POS0: [MjtNum; 3] = [0.0, 0.0, 0.0];
        const DIR0: [MjtNum; 3] = [0.0, 0.0, -1.0];
        const ATTENUATION: [f32; 3] = [0.1, 0.05, 0.01];
        const CUTOFF: f32 = 45.0;
        const EXPONENT: f32 = 2.0;
        const AMBIENT: [f32; 3] = [0.1, 0.1, 0.1];
        const DIFFUSE: [f32; 3] = [1.0, 1.0, 1.0];
        const SPECULAR: [f32; 3] = [1.0, 1.0, 1.0];

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let info_light = model.light(LIGHT_NAME).unwrap();
        let view_light = info_light.view(&model);

        assert_eq!(view_light.mode[0], MODE);
        assert_eq!(view_light.bodyid[0] as usize, BODYID);
        assert_eq!(view_light.targetbodyid[0], -1);
        assert_eq!(view_light.r#type[0], TYPE);
        assert_eq!(view_light.castshadow[0], CASTSHADOW);
        assert_eq!(view_light.active[0], ACTIVE);

        assert_eq!(view_light.pos[..], POS);
        assert_eq!(view_light.dir[..], DIR);
        assert_eq!(view_light.pos0[..], POS0);
        assert_eq!(view_light.dir0[..], DIR0);
        assert_eq!(view_light.attenuation[..], ATTENUATION);
        assert_eq!(view_light.cutoff[0], CUTOFF);
        assert_eq!(view_light.exponent[0], EXPONENT);
        assert_eq!(view_light.ambient[..], AMBIENT);
        assert_eq!(view_light.diffuse[..], DIFFUSE);
        assert_eq!(view_light.specular[..], SPECULAR);
    }

    #[test]
    fn test_connect_eq_view() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();

        // Take the third equality constraint
        let info_eq = model.equality("eq3").unwrap();
        let view_eq = info_eq.view(&model);

        // Check type
        assert_eq!(view_eq.r#type[0], MjtEq::mjEQ_CONNECT);

        // Check connected bodies
        assert_eq!(view_eq.obj1id[0], model.name_to_id(MjtObj::mjOBJ_BODY, "eq_body3").unwrap() as i32);
        assert_eq!(view_eq.obj2id[0], model.name_to_id(MjtObj::mjOBJ_BODY, "eq_body4").unwrap() as i32);
        assert_eq!(view_eq.objtype[0], MjtObj::mjOBJ_BODY);

        // Check active
        assert!(view_eq.active0[0]);

        // Check anchor position stored in eq_data
        let anchor = &view_eq.data[0..3];
        assert_eq!(anchor[0], 0.0);
        assert_eq!(anchor[1], 5.0);
        assert_eq!(anchor[2], 0.0);
    }

    #[test]
    fn test_hfield_view() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();

        // Access the second height field
        let info_hf = model.hfield("hf2").unwrap();
        let view_hf = info_hf.view(&model);

        // Expected values
        let expected_size: [f64; 4] = [1.0, 1.0, 1.0, 5.25]; // radius_x, radius_y, elevation_z, base_z
        let expected_nrow = 5;
        let expected_ncol = 3;
        let expected_data: [f32; 15] = [0.0; 15];

        // Assertions
        assert_eq!(view_hf.size[..], expected_size);
        assert_eq!(view_hf.nrow[0], expected_nrow);
        assert_eq!(view_hf.ncol[0], expected_ncol);

        // hfield_data length should match nrow * ncol
        assert_eq!(view_hf.data.as_ref().unwrap().len(), (expected_nrow * expected_ncol) as usize);
        assert_eq!(&view_hf.data.as_ref().unwrap()[..], &expected_data[..]);

        // Pathadr is -1 (no external file)
        assert_eq!(view_hf.pathadr[0], -1);
    }

    /// Tests [`MjModel::extract_state_into`] for correctness.
    #[test]
    fn test_state_extract() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        /* Test of extraction into existing buffer */
        // Physics is subset of full physics.
        // Extract physics from full physics.
        let state_full_physics = data.state(MjtState::mjSTATE_FULLPHYSICS as u32);
        let state_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);

        let required_size = model.state_size(MjtState::mjSTATE_PHYSICS as u32);
        let mut dst_buffer = vec![0.0; required_size].into_boxed_slice();
        let _bytes_written = model.extract_state_into(
            &state_full_physics, MjtState::mjSTATE_FULLPHYSICS as u32,
            &mut dst_buffer, MjtState::mjSTATE_PHYSICS as u32
        );

        assert_eq!(state_physics, dst_buffer);

        /* Test of extraction into new buffer (internally) */
        // Physics is subset of full physics.
        // Extract physics from full physics.
        let state_full_physics = data.state(MjtState::mjSTATE_FULLPHYSICS as u32);
        let state_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);

        let dst_buffer = model.extract_state(
            &state_full_physics, MjtState::mjSTATE_FULLPHYSICS as u32,
            MjtState::mjSTATE_PHYSICS as u32
        );

        assert_eq!(state_physics, dst_buffer);
    }

    /// Tests for the expected panic when giving a source spec that does not match
    /// the source array in state extraction.

    #[test]
    fn test_state_extract_state_invalid_src() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let state_full_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);
        let res = model.try_extract_state(
            &state_full_physics, MjtState::mjSTATE_FULLPHYSICS as u32,
            MjtState::mjSTATE_PHYSICS as u32
        );

        let err = res.unwrap_err();
        assert!(matches!(err, MjModelError::StateSliceLengthMismatch { .. }));
    }

    #[test]
    fn test_state_extract_state_into_invalid_src() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let required_size = model.state_size(MjtState::mjSTATE_PHYSICS as u32);
        let mut dst_buffer = vec![0.0; required_size].into_boxed_slice();
        let state_full_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);
        let res = model.try_extract_state_into(
            &state_full_physics, MjtState::mjSTATE_FULLPHYSICS as u32,
            &mut dst_buffer, MjtState::mjSTATE_PHYSICS as u32
        );

        let err = res.unwrap_err();
        assert!(matches!(err, MjModelError::StateSliceLengthMismatch { .. }));
    }

    #[test]
    fn test_state_extract_dst_spec_not_subset() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let state_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);
        let res = model.try_extract_state(
            &state_physics, MjtState::mjSTATE_PHYSICS as u32,
            MjtState::mjSTATE_FULLPHYSICS as u32
        );

        let err = res.unwrap_err();
        assert!(matches!(err, MjModelError::SpecNotSubset));
    }

    #[test]
    fn test_state_extract_into_dst_spec_not_subset() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let state_physics = data.state(MjtState::mjSTATE_PHYSICS as u32);
        let mut dst = vec![0.0; model.state_size(MjtState::mjSTATE_PHYSICS as u32)];

        let res = model.try_extract_state_into(
            &state_physics, MjtState::mjSTATE_PHYSICS as u32,
            &mut dst, MjtState::mjSTATE_FULLPHYSICS as u32
        );

        let err = res.unwrap_err();
        assert!(matches!(err, MjModelError::SpecNotSubset));
    }

    #[test]
    fn test_state_extract_into_dst_buffer_too_small() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let state_full = data.state(MjtState::mjSTATE_FULLPHYSICS as u32);
        let required = model.state_size(MjtState::mjSTATE_PHYSICS as u32);
        // make buffer smaller than required
        let mut dst = vec![0.0; required.saturating_sub(1)];

        let res = model.try_extract_state_into(
            &state_full, MjtState::mjSTATE_FULLPHYSICS as u32,
            &mut dst, MjtState::mjSTATE_PHYSICS as u32
        );

        let err = res.unwrap_err();
        assert!(matches!(err, MjModelError::BufferTooSmall { .. }));
    }

    #[test]
    fn test_state_extract_zero_spec() {
        use crate::wrappers::mj_data::MjtState;

        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let data = MjData::new(&model);

        let state_full = data.state(MjtState::mjSTATE_FULLPHYSICS as u32);

        // extract zero-sized spec -> empty slice
        let dst = model.extract_state(&state_full, MjtState::mjSTATE_FULLPHYSICS as u32, 0u32);
        assert!(dst.is_empty());

        // extract_into with zero-sized spec -> writes 0 elements
        let buf: &mut [f64] = &mut [];
        let written = model.extract_state_into(&state_full, MjtState::mjSTATE_FULLPHYSICS as u32, buf, 0u32);
        assert_eq!(written, 0);
    }

    /**************************************************************************/
    // Force-cast macro correctness tests for MjModel
    /**************************************************************************/

    /// Verifies [force]-cast array grouping for body_pos (&[[MjtNum; 3]]),
    /// body_quat (&[[MjtNum; 4]]), body_inertia (&[[MjtNum; 3]]), body_invweight0 (&[[MjtNum; 2]]).
    #[test]
    fn test_force_cast_body_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nbody = model.ffi().nbody as usize;

        let body_pos = model.body_pos();
        let body_quat = model.body_quat();
        let body_inertia = model.body_inertia();
        let body_invweight0 = model.body_invweight0();
        let body_ipos = model.body_ipos();
        let body_iquat = model.body_iquat();

        assert_eq!(body_pos.len(), nbody);
        assert_eq!(body_quat.len(), nbody);
        assert_eq!(body_inertia.len(), nbody);
        assert_eq!(body_invweight0.len(), nbody);
        assert_eq!(body_ipos.len(), nbody);
        assert_eq!(body_iquat.len(), nbody);

        // Cross-validate against raw FFI
        for i in 0..nbody {
            for j in 0..3 {
                assert_eq!(body_pos[i][j], unsafe { *model.ffi().body_pos.add(i * 3 + j) },
                    "body_pos[{}][{}] mismatch", i, j);
            }
            for j in 0..4 {
                assert_eq!(body_quat[i][j], unsafe { *model.ffi().body_quat.add(i * 4 + j) },
                    "body_quat[{}][{}] mismatch", i, j);
            }
            for j in 0..3 {
                assert_eq!(body_inertia[i][j], unsafe { *model.ffi().body_inertia.add(i * 3 + j) },
                    "body_inertia[{}][{}] mismatch", i, j);
            }
            for j in 0..2 {
                assert_eq!(body_invweight0[i][j], unsafe { *model.ffi().body_invweight0.add(i * 2 + j) },
                    "body_invweight0[{}][{}] mismatch", i, j);
            }
        }
    }

    /// Verifies [force]-cast enum for jnt_type (*mut i32 -> *mut MjtJoint).
    #[test]
    fn test_force_cast_jnt_type_enum() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let njnt = model.ffi().njnt as usize;
        let jnt_type = model.jnt_type();

        assert_eq!(jnt_type.len(), njnt);

        // Cross-validate with raw FFI
        for i in 0..njnt {
            let raw_i32 = unsafe { *model.ffi().jnt_type.add(i) };
            let expected: MjtJoint = unsafe { crate::util::force_cast(raw_i32) };
            assert_eq!(jnt_type[i], expected,
                "jnt_type[{}]: got {:?}, expected {:?} (raw={})", i, jnt_type[i], expected, raw_i32);
        }

        // Verify known joints: "ball" is free, "rod" is slide
        let ball_jnt = model.joint("ball").unwrap();
        assert_eq!(jnt_type[ball_jnt.id], MjtJoint::mjJNT_FREE);

        let rod_jnt = model.joint("rod").unwrap();
        assert_eq!(jnt_type[rod_jnt.id], MjtJoint::mjJNT_SLIDE);
    }

    /// Verifies [force]-cast bool for jnt_limited (*mut u8 -> *mut bool).
    #[test]
    fn test_force_cast_jnt_limited_bool() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let njnt = model.ffi().njnt as usize;
        let jnt_limited = model.jnt_limited();

        assert_eq!(jnt_limited.len(), njnt);

        // Cross-validate with raw FFI
        for i in 0..njnt {
            let raw_bool = unsafe { *model.ffi().jnt_limited.add(i) };
            assert_eq!(jnt_limited[i], raw_bool,
                "jnt_limited[{}] mismatch: bool={}, raw={}", i, jnt_limited[i], raw_bool);
        }

        // "rod" joint has range="0 1" -> limited=true; "ball" is free -> limited=false
        let rod_jnt = model.joint("rod").unwrap();
        assert!(jnt_limited[rod_jnt.id]);

        let ball_jnt = model.joint("ball").unwrap();
        assert!(!jnt_limited[ball_jnt.id]);
    }

    /// Verifies [force]-cast enum for geom_type (*mut i32 -> *mut MjtGeom).
    #[test]
    fn test_force_cast_geom_type_enum() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let ngeom = model.ffi().ngeom as usize;
        let geom_type = model.geom_type();

        assert_eq!(geom_type.len(), ngeom);

        // Cross-validate
        for i in 0..ngeom {
            let raw_i32 = unsafe { *model.ffi().geom_type.add(i) };
            let expected: MjtGeom = unsafe { crate::util::force_cast(raw_i32) };
            assert_eq!(geom_type[i], expected);
        }

        // Verify known geoms
        let sphere_geom = model.geom("green_sphere").unwrap();
        assert_eq!(geom_type[sphere_geom.id], MjtGeom::mjGEOM_SPHERE);

        let floor_geom = model.geom("floor").unwrap();
        assert_eq!(geom_type[floor_geom.id], MjtGeom::mjGEOM_PLANE);

        let rod_geom = model.geom("rod").unwrap();
        assert_eq!(geom_type[rod_geom.id], MjtGeom::mjGEOM_CYLINDER);
    }

    /// Verifies [force]-cast for geom_size (&[[MjtNum; 3]]), geom_pos (&[[MjtNum; 3]]),
    /// geom_quat (&[[MjtNum; 4]]), geom_rgba (&[[f32; 4]]), geom_friction (&[[MjtNum; 3]]),
    /// geom_aabb (&[[MjtNum; 6]]).
    #[test]
    fn test_force_cast_geom_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let ngeom = model.ffi().ngeom as usize;

        let geom_size = model.geom_size();
        let geom_pos = model.geom_pos();
        let geom_quat = model.geom_quat();
        let geom_rgba = model.geom_rgba();
        let geom_friction = model.geom_friction();
        let geom_aabb = model.geom_aabb();

        assert_eq!(geom_size.len(), ngeom);
        assert_eq!(geom_pos.len(), ngeom);
        assert_eq!(geom_quat.len(), ngeom);
        assert_eq!(geom_rgba.len(), ngeom);
        assert_eq!(geom_friction.len(), ngeom);
        assert_eq!(geom_aabb.len(), ngeom);

        // Cross-validate all against FFI
        for i in 0..ngeom {
            for j in 0..3 {
                assert_eq!(geom_size[i][j], unsafe { *model.ffi().geom_size.add(i * 3 + j) });
                assert_eq!(geom_pos[i][j], unsafe { *model.ffi().geom_pos.add(i * 3 + j) });
                assert_eq!(geom_friction[i][j], unsafe { *model.ffi().geom_friction.add(i * 3 + j) });
            }
            for j in 0..4 {
                assert_eq!(geom_quat[i][j], unsafe { *model.ffi().geom_quat.add(i * 4 + j) });
                assert_eq!(geom_rgba[i][j], unsafe { *model.ffi().geom_rgba.add(i * 4 + j) });
            }
            for j in 0..6 {
                assert_eq!(geom_aabb[i][j], unsafe { *model.ffi().geom_aabb.add(i * 6 + j) });
            }
        }

        // Verify a known geom: "green_sphere" has rgba="0 1 0 1" and size="0.1"
        let gs = model.geom("green_sphere").unwrap();
        assert_eq!(geom_rgba[gs.id], [0.0f32, 1.0, 0.0, 1.0]);
        assert_relative_eq!(geom_size[gs.id][0], 0.1, epsilon = 1e-9);
    }

    /// Verifies [force]-cast for camera arrays: cam_mode (MjtCamLight), cam_projection (MjtProjection),
    /// cam_resolution (&[[i32; 2]]), cam_sensorsize (&[[f32; 2]]), cam_intrinsic (&[[f32; 4]]),
    /// cam_mat0 (&[[MjtNum; 9]]).
    #[test]
    fn test_force_cast_camera_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let ncam = model.ffi().ncam as usize;

        if ncam == 0 {
            // The EXAMPLE_MODEL has a camera, but guard just in case
            return;
        }

        let cam_mode = model.cam_mode();
        let cam_projection = model.cam_projection();
        let cam_resolution = model.cam_resolution();
        let cam_sensorsize = model.cam_sensorsize();
        let cam_intrinsic = model.cam_intrinsic();
        let cam_mat0 = model.cam_mat0();

        assert_eq!(cam_mode.len(), ncam);
        assert_eq!(cam_projection.len(), ncam);
        assert_eq!(cam_resolution.len(), ncam);
        assert_eq!(cam_sensorsize.len(), ncam);
        assert_eq!(cam_intrinsic.len(), ncam);
        assert_eq!(cam_mat0.len(), ncam);

        // Cross-validate enum casts against raw FFI
        for i in 0..ncam {
            let raw_mode = unsafe { *model.ffi().cam_mode.add(i) };
            let expected_mode: MjtCamLight = unsafe { crate::util::force_cast(raw_mode) };
            assert_eq!(cam_mode[i], expected_mode);

            let raw_proj = unsafe { *model.ffi().cam_projection.add(i) };
            let expected_proj: MjtProjection = unsafe { crate::util::force_cast(raw_proj) };
            assert_eq!(cam_projection[i], expected_proj);

            for j in 0..2 {
                assert_eq!(cam_resolution[i][j], unsafe { *model.ffi().cam_resolution.add(i * 2 + j) });
                assert_eq!(cam_sensorsize[i][j], unsafe { *model.ffi().cam_sensorsize.add(i * 2 + j) });
            }
            for j in 0..4 {
                assert_eq!(cam_intrinsic[i][j], unsafe { *model.ffi().cam_intrinsic.add(i * 4 + j) });
            }
            for j in 0..9 {
                assert_eq!(cam_mat0[i][j], unsafe { *model.ffi().cam_mat0.add(i * 9 + j) });
            }
        }

        // Verify known camera: "cam1" has resolution="100 200"
        let cam1 = model.camera("cam1").unwrap();
        assert_eq!(cam_resolution[cam1.id], [100, 200]);
    }

    /// Verifies [force]-cast for bvh_child (&[[i32; 2]]) and bvh_aabb (&[[MjtNum; 6]]).
    #[test]
    fn test_force_cast_bvh_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nbvh = model.ffi().nbvh as usize;

        let bvh_child = model.bvh_child();
        assert_eq!(bvh_child.len(), nbvh);

        for i in 0..nbvh {
            for j in 0..2 {
                assert_eq!(bvh_child[i][j], unsafe { *model.ffi().bvh_child.add(i * 2 + j) });
            }
        }

        let nbvhstatic = model.ffi().nbvhstatic as usize;
        let bvh_aabb = model.bvh_aabb();
        assert_eq!(bvh_aabb.len(), nbvhstatic);

        for i in 0..nbvhstatic {
            for j in 0..6 {
                assert_eq!(bvh_aabb[i][j], unsafe { *model.ffi().bvh_aabb.add(i * 6 + j) });
            }
        }
    }

    /// Verifies [force]-cast enum: body_sameframe and geom_sameframe (MjtSameFrame).
    #[test]
    fn test_force_cast_sameframe_enum() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nbody = model.ffi().nbody as usize;
        let ngeom = model.ffi().ngeom as usize;

        let body_sameframe = model.body_sameframe();
        let geom_sameframe = model.geom_sameframe();

        assert_eq!(body_sameframe.len(), nbody);
        assert_eq!(geom_sameframe.len(), ngeom);

        for i in 0..nbody {
            let raw = unsafe { *model.ffi().body_sameframe.add(i) };
            let expected: MjtSameFrame = unsafe { crate::util::force_cast(raw) };
            assert_eq!(body_sameframe[i], expected, "body_sameframe[{}] mismatch", i);
        }

        for i in 0..ngeom {
            let raw = unsafe { *model.ffi().geom_sameframe.add(i) };
            let expected: MjtSameFrame = unsafe { crate::util::force_cast(raw) };
            assert_eq!(geom_sameframe[i], expected, "geom_sameframe[{}] mismatch", i);
        }
    }

    /// Verifies [force]-cast for equality constraint arrays: eq_type (MjtEq),
    /// eq_objtype (MjtObj), eq_active0 (bool), eq_data (&[[MjtNum; mjNEQDATA]]).
    #[test]
    fn test_force_cast_equality_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let neq = model.ffi().neq as usize;

        if neq == 0 {
            return;
        }

        let eq_type = model.eq_type();
        let eq_objtype = model.eq_objtype();
        let eq_active0 = model.eq_active0();

        assert_eq!(eq_type.len(), neq);
        assert_eq!(eq_objtype.len(), neq);
        assert_eq!(eq_active0.len(), neq);

        // Cross-validate enum casts
        for i in 0..neq {
            let raw_type = unsafe { *model.ffi().eq_type.add(i) };
            let expected_type: MjtEq = unsafe { crate::util::force_cast(raw_type) };
            assert_eq!(eq_type[i], expected_type);

            let raw_objtype = unsafe { *model.ffi().eq_objtype.add(i) };
            let expected_objtype: MjtObj = unsafe { crate::util::force_cast(raw_objtype) };
            assert_eq!(eq_objtype[i], expected_objtype);

            let raw_active = unsafe { *model.ffi().eq_active0.add(i) };
            assert_eq!(eq_active0[i], raw_active);
        }

        // Verify known equality: "eq1" is a connect constraint
        let eq1 = model.equality("eq1").unwrap();
        assert_eq!(eq_type[eq1.id], MjtEq::mjEQ_CONNECT);
        assert_eq!(eq_objtype[eq1.id], MjtObj::mjOBJ_BODY);
        assert!(eq_active0[eq1.id]);
    }

    /// Verifies [force]-cast for sensor arrays: sensor_type (MjtSensor), sensor_datatype (MjtDataType),
    /// sensor_needstage (MjtStage), sensor_objtype (MjtObj), sensor_reftype (MjtObj).
    #[test]
    fn test_force_cast_sensor_model_enums() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nsensor = model.ffi().nsensor as usize;

        if nsensor == 0 {
            return;
        }

        let sensor_type = model.sensor_type();
        let sensor_datatype = model.sensor_datatype();
        let sensor_needstage = model.sensor_needstage();
        let sensor_objtype = model.sensor_objtype();
        let sensor_reftype = model.sensor_reftype();

        assert_eq!(sensor_type.len(), nsensor);
        assert_eq!(sensor_datatype.len(), nsensor);
        assert_eq!(sensor_needstage.len(), nsensor);
        assert_eq!(sensor_objtype.len(), nsensor);
        assert_eq!(sensor_reftype.len(), nsensor);

        for i in 0..nsensor {
            let raw_type = unsafe { *model.ffi().sensor_type.add(i) };
            let raw_datatype = unsafe { *model.ffi().sensor_datatype.add(i) };
            let raw_needstage = unsafe { *model.ffi().sensor_needstage.add(i) };
            let raw_objtype = unsafe { *model.ffi().sensor_objtype.add(i) };
            let raw_reftype = unsafe { *model.ffi().sensor_reftype.add(i) };

            assert_eq!(sensor_type[i], unsafe { crate::util::force_cast::<_, MjtSensor>(raw_type) });
            assert_eq!(sensor_datatype[i], unsafe { crate::util::force_cast::<_, MjtDataType>(raw_datatype) });
            assert_eq!(sensor_needstage[i], unsafe { crate::util::force_cast::<_, MjtStage>(raw_needstage) });
            assert_eq!(sensor_objtype[i], unsafe { crate::util::force_cast::<_, MjtObj>(raw_objtype) });
            assert_eq!(sensor_reftype[i], unsafe { crate::util::force_cast::<_, MjtObj>(raw_reftype) });
        }

        // Verify known sensor: "touch" is a touch sensor on a site
        let touch = model.sensor("touch").unwrap();
        assert_eq!(sensor_type[touch.id], MjtSensor::mjSENS_TOUCH);
        assert_eq!(sensor_objtype[touch.id], MjtObj::mjOBJ_SITE);
    }

    /// Verifies [force]-cast for actuator enum arrays: trntype (MjtTrn), dyntype (MjtDyn),
    /// gaintype (MjtGain), biastype (MjtBias), and bool ctrllimited, forcelimited, actlimited.
    #[test]
    fn test_force_cast_actuator_model_enums_and_bools() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nactuator = model.ffi().nactuator as usize;
        let nu = model.ffi().nu as usize;

        if nactuator == 0 {
            return;
        }

        let trntype = model.actuator_trntype();
        let dyntype = model.actuator_dyntype();
        let gaintype = model.actuator_gaintype();
        let biastype = model.actuator_biastype();
        let ctrllimited = model.actuator_ctrllimited();
        let forcelimited = model.actuator_forcelimited();
        let actlimited = model.actuator_actlimited();
        let actearly = model.actuator_actearly();

        assert_eq!(trntype.len(), nactuator);
        assert_eq!(dyntype.len(), nactuator);
        assert_eq!(gaintype.len(), nactuator);
        assert_eq!(biastype.len(), nactuator);
        assert_eq!(ctrllimited.len(), nu);
        assert_eq!(forcelimited.len(), nactuator);
        assert_eq!(actlimited.len(), nactuator);
        assert_eq!(actearly.len(), nactuator);

        for i in 0..nactuator {
            // Enum cross-validation
            assert_eq!(trntype[i], unsafe { crate::util::force_cast::<_, MjtTrn>(*model.ffi().actuator_trntype.add(i)) });
            assert_eq!(dyntype[i], unsafe { crate::util::force_cast::<_, MjtDyn>(*model.ffi().actuator_dyntype.add(i)) });
            assert_eq!(gaintype[i], unsafe { crate::util::force_cast::<_, MjtGain>(*model.ffi().actuator_gaintype.add(i)) });
            assert_eq!(biastype[i], unsafe { crate::util::force_cast::<_, MjtBias>(*model.ffi().actuator_biastype.add(i)) });

            // Bool cross-validation
            let raw_ctrllimited = unsafe { *model.ffi().actuator_ctrllimited.add(i) };
            assert_eq!(ctrllimited[i], raw_ctrllimited);
            let raw_forcelimited = unsafe { *model.ffi().actuator_forcelimited.add(i) };
            assert_eq!(forcelimited[i], raw_forcelimited);
            let raw_actlimited = unsafe { *model.ffi().actuator_actlimited.add(i) };
            assert_eq!(actlimited[i], raw_actlimited);
            let raw_actearly = unsafe { *model.ffi().actuator_actearly.add(i) };
            assert_eq!(actearly[i], raw_actearly);
        }

        // Verify known actuator: "slider" has biastype=affine, gaintype=fixed, ctrllimited=true
        let slider = model.actuator("slider").unwrap();
        assert_eq!(biastype[slider.id], MjtBias::mjBIAS_AFFINE);
        assert_eq!(gaintype[slider.id], MjtGain::mjGAIN_FIXED);
        assert!(ctrllimited[slider.id]);
    }

    /// Verifies [force]-cast for actuator parameter arrays: dynprm, gainprm, biasprm, ctrlrange,
    /// gear (&[[MjtNum; 6]]).
    #[test]
    fn test_force_cast_actuator_param_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nactuator = model.ffi().nactuator as usize;
        let nout = model.ffi().nout as usize;
        let nu = model.ffi().nu as usize;

        let dynprm = model.actuator_dynprm();
        let ctrlrange = model.actuator_ctrlrange();
        let gear = model.actuator_gear();
        let trnid = model.actuator_trnid();

        assert_eq!(dynprm.len(), nactuator);
        assert_eq!(ctrlrange.len(), nu);
        assert_eq!(gear.len(), nout);
        assert_eq!(trnid.len(), nactuator);

        // Verify "slider" dynprm and ctrlrange
        let slider = model.actuator("slider").unwrap();
        assert_eq!(dynprm[slider.id][0..10], [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]);
        assert_eq!(ctrlrange[slider.id], [0.0, 1.0]);

        // Verify "slider2" has reversed dynprm
        let slider2 = model.actuator("slider2").unwrap();
        assert_eq!(dynprm[slider2.id][0..10], [10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0]);

        // Cross-validate FFI for gear (stride 6), trnid (stride 2) and ctrlrange (stride 2)
        for i in 0..nout {
            for j in 0..6 {
                assert_eq!(gear[i][j], unsafe { *model.ffi().actuator_gear.add(i * 6 + j) });
            }
        }
        for i in 0..nactuator {
            for j in 0..2 {
                assert_eq!(trnid[i][j], unsafe { *model.ffi().actuator_trnid.add(i * 2 + j) });
            }
        }
        for i in 0..nu {
            for j in 0..2 {
                assert_eq!(ctrlrange[i][j], unsafe { *model.ffi().actuator_ctrlrange.add(i * 2 + j) });
            }
        }
    }

    /// Verifies [force]-cast for tendon bools and arrays: tendon_limited (bool),
    /// tendon_range (&[[MjtNum; 2]]), tendon_rgba (&[[f32; 4]]), tendon_treeid (&[[i32; 2]]).
    #[test]
    fn test_force_cast_tendon_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let ntendon = model.ffi().ntendon as usize;

        if ntendon == 0 {
            return;
        }

        let tendon_limited = model.tendon_limited();
        let tendon_range = model.tendon_range();
        let tendon_rgba = model.tendon_rgba();
        let tendon_treeid = model.tendon_treeid();
        let tendon_lengthspring = model.tendon_lengthspring();

        assert_eq!(tendon_limited.len(), ntendon);
        assert_eq!(tendon_range.len(), ntendon);
        assert_eq!(tendon_rgba.len(), ntendon);
        assert_eq!(tendon_treeid.len(), ntendon);
        assert_eq!(tendon_lengthspring.len(), ntendon);

        for i in 0..ntendon {
            let raw_limited = unsafe { *model.ffi().tendon_limited.add(i) };
            assert_eq!(tendon_limited[i], raw_limited);

            for j in 0..2 {
                assert_eq!(tendon_range[i][j], unsafe { *model.ffi().tendon_range.add(i * 2 + j) });
                assert_eq!(tendon_treeid[i][j], unsafe { *model.ffi().tendon_treeid.add(i * 2 + j) });
                assert_eq!(tendon_lengthspring[i][j], unsafe { *model.ffi().tendon_lengthspring.add(i * 2 + j) });
            }

            for j in 0..4 {
                assert_eq!(tendon_rgba[i][j], unsafe { *model.ffi().tendon_rgba.add(i * 4 + j) });
            }
        }

        // Verify known tendon: "tendon2" limited=true, range=(0,1), rgba=(0, 0.1, 1, 1)
        let ten2 = model.tendon("tendon2").unwrap();
        assert!(tendon_limited[ten2.id]);
        assert_eq!(tendon_range[ten2.id], [0.0, 1.0]);
        assert_relative_eq!(tendon_rgba[ten2.id][0], 0.0f32, epsilon = 1e-6);
        assert_relative_eq!(tendon_rgba[ten2.id][1], 0.1f32, epsilon = 1e-6);
    }

    /// Verifies [force]-cast for texture enum: tex_type (MjtTexture), tex_colorspace (MjtColorSpace).
    #[test]
    fn test_force_cast_texture_model_enums() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let ntex = model.ffi().ntex as usize;

        if ntex == 0 {
            return;
        }

        let tex_type = model.tex_type();
        let tex_colorspace = model.tex_colorspace();

        assert_eq!(tex_type.len(), ntex);
        assert_eq!(tex_colorspace.len(), ntex);

        for i in 0..ntex {
            let raw_type = unsafe { *model.ffi().tex_type.add(i) };
            let expected_type: MjtTexture = unsafe { crate::util::force_cast(raw_type) };
            assert_eq!(tex_type[i], expected_type);

            let raw_cs = unsafe { *model.ffi().tex_colorspace.add(i) };
            let expected_cs: MjtColorSpace = unsafe { crate::util::force_cast(raw_cs) };
            assert_eq!(tex_colorspace[i], expected_cs);
        }

        // "wall_tex" is 2D, sRGB
        let wall_tex = model.texture("wall_tex").unwrap();
        assert_eq!(tex_type[wall_tex.id], MjtTexture::mjTEXTURE_2D);
        assert_eq!(tex_colorspace[wall_tex.id], MjtColorSpace::mjCOLORSPACE_SRGB);
    }

    /// Verifies [force]-cast for material bools and f32 arrays: mat_texuniform (bool),
    /// mat_texrepeat (&[[f32; 2]]), mat_rgba (&[[f32; 4]]).
    #[test]
    fn test_force_cast_material_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nmat = model.ffi().nmat as usize;

        if nmat == 0 {
            return;
        }

        let mat_texuniform = model.mat_texuniform();
        let mat_texrepeat = model.mat_texrepeat();
        let mat_rgba = model.mat_rgba();

        assert_eq!(mat_texuniform.len(), nmat);
        assert_eq!(mat_texrepeat.len(), nmat);
        assert_eq!(mat_rgba.len(), nmat);

        for i in 0..nmat {
            let raw_uniform = unsafe { *model.ffi().mat_texuniform.add(i) };
            assert_eq!(mat_texuniform[i], raw_uniform);

            for j in 0..2 {
                assert_eq!(mat_texrepeat[i][j], unsafe { *model.ffi().mat_texrepeat.add(i * 2 + j) });
            }
            for j in 0..4 {
                assert_eq!(mat_rgba[i][j], unsafe { *model.ffi().mat_rgba.add(i * 4 + j) });
            }
        }

        // "also_wood_material" has texuniform=false, texrepeat=[2,2], rgba=[0.8,0.5,0.3,1.0]
        let mat = model.material("also_wood_material").unwrap();
        assert!(!mat_texuniform[mat.id]);
        assert_eq!(mat_texrepeat[mat.id], [2.0f32, 2.0]);
        assert_eq!(mat_rgba[mat.id], [0.8f32, 0.5, 0.3, 1.0]);
    }

    /// Verifies [force]-cast for light arrays: light mode/type enums, light_castshadow/active bools,
    /// light_attenuation (&[[f32; 3]]), light_ambient/diffuse/specular (&[[f32; 3]]),
    /// light_pos/dir (&[[MjtNum; 3]]).
    #[test]
    fn test_force_cast_light_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nlight = model.ffi().nlight as usize;

        if nlight == 0 {
            return;
        }

        let light_mode = model.light_mode();
        let light_type = model.light_type();
        let light_castshadow = model.light_castshadow();
        let light_active = model.light_active();
        let light_attenuation = model.light_attenuation();
        let light_ambient = model.light_ambient();
        let light_diffuse = model.light_diffuse();
        let light_specular = model.light_specular();
        let light_pos = model.light_pos();
        let light_dir = model.light_dir();

        assert_eq!(light_mode.len(), nlight);
        assert_eq!(light_type.len(), nlight);
        assert_eq!(light_castshadow.len(), nlight);
        assert_eq!(light_active.len(), nlight);

        for i in 0..nlight {
            assert_eq!(light_mode[i], unsafe { crate::util::force_cast::<_, MjtCamLight>(*model.ffi().light_mode.add(i)) });
            assert_eq!(light_type[i], unsafe { crate::util::force_cast::<_, MjtLightType>(*model.ffi().light_type.add(i)) });

            let raw_shadow = unsafe { *model.ffi().light_castshadow.add(i) };
            assert_eq!(light_castshadow[i], raw_shadow);
            let raw_active = unsafe { *model.ffi().light_active.add(i) };
            assert_eq!(light_active[i], raw_active);

            for j in 0..3 {
                assert_eq!(light_attenuation[i][j], unsafe { *model.ffi().light_attenuation.add(i * 3 + j) });
                assert_eq!(light_ambient[i][j], unsafe { *model.ffi().light_ambient.add(i * 3 + j) });
                assert_eq!(light_diffuse[i][j], unsafe { *model.ffi().light_diffuse.add(i * 3 + j) });
                assert_eq!(light_specular[i][j], unsafe { *model.ffi().light_specular.add(i * 3 + j) });
                assert_eq!(light_pos[i][j], unsafe { *model.ffi().light_pos.add(i * 3 + j) });
                assert_eq!(light_dir[i][j], unsafe { *model.ffi().light_dir.add(i * 3 + j) });
            }
        }

        // Verify known: "lamp_light2" is spot, mode=fixed, castshadow=true
        let l2 = model.light("lamp_light2").unwrap();
        assert_eq!(light_mode[l2.id], MjtCamLight::mjCAMLIGHT_FIXED);
        assert_eq!(light_type[l2.id], MjtLightType::mjLIGHT_SPOT);
        assert!(light_castshadow[l2.id]);
    }

    /// Verifies [force]-cast for the site arrays: site_type (MjtGeom), site_sameframe (MjtSameFrame),
    /// site_size (&[[MjtNum; 3]]), site_pos (&[[MjtNum; 3]]), site_quat (&[[MjtNum; 4]]),
    /// site_rgba (&[[f32; 4]]).
    #[test]
    fn test_force_cast_site_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nsite = model.ffi().nsite as usize;

        let site_type = model.site_type();
        let site_sameframe = model.site_sameframe();
        let site_size = model.site_size();
        let site_pos = model.site_pos();
        let site_quat = model.site_quat();
        let site_rgba = model.site_rgba();

        assert_eq!(site_type.len(), nsite);
        assert_eq!(site_sameframe.len(), nsite);
        assert_eq!(site_size.len(), nsite);
        assert_eq!(site_pos.len(), nsite);
        assert_eq!(site_quat.len(), nsite);
        assert_eq!(site_rgba.len(), nsite);

        for i in 0..nsite {
            assert_eq!(site_type[i], unsafe { crate::util::force_cast::<_, MjtGeom>(*model.ffi().site_type.add(i)) });
            assert_eq!(site_sameframe[i], unsafe { crate::util::force_cast::<_, MjtSameFrame>(*model.ffi().site_sameframe.add(i)) });

            for j in 0..3 {
                assert_eq!(site_size[i][j], unsafe { *model.ffi().site_size.add(i * 3 + j) });
                assert_eq!(site_pos[i][j], unsafe { *model.ffi().site_pos.add(i * 3 + j) });
            }
            for j in 0..4 {
                assert_eq!(site_quat[i][j], unsafe { *model.ffi().site_quat.add(i * 4 + j) });
                assert_eq!(site_rgba[i][j], unsafe { *model.ffi().site_rgba.add(i * 4 + j) });
            }
        }
    }

    /// Verifies [force]-cast for joint solver arrays: jnt_solref (&[[MjtNum; mjNREF]]),
    /// jnt_solimp (&[[MjtNum; mjNIMP]]), jnt_pos (&[[MjtNum; 3]]), jnt_axis (&[[MjtNum; 3]]),
    /// jnt_range (&[[MjtNum; 2]]).
    #[test]
    fn test_force_cast_joint_model_solver_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let njnt = model.ffi().njnt as usize;

        let jnt_solref = model.jnt_solref();
        let jnt_solimp = model.jnt_solimp();
        let jnt_pos = model.jnt_pos();
        let jnt_axis = model.jnt_axis();
        let jnt_range = model.jnt_range();

        assert_eq!(jnt_solref.len(), njnt);
        assert_eq!(jnt_solimp.len(), njnt);
        assert_eq!(jnt_pos.len(), njnt);
        assert_eq!(jnt_axis.len(), njnt);
        assert_eq!(jnt_range.len(), njnt);

        let nref = mjNREF as usize;
        let nimp = mjNIMP as usize;

        for i in 0..njnt {
            for j in 0..nref {
                assert_eq!(jnt_solref[i][j], unsafe { *model.ffi().jnt_solref.add(i * nref + j) });
            }
            for j in 0..nimp {
                assert_eq!(jnt_solimp[i][j], unsafe { *model.ffi().jnt_solimp.add(i * nimp + j) });
            }
            for j in 0..3 {
                assert_eq!(jnt_pos[i][j], unsafe { *model.ffi().jnt_pos.add(i * 3 + j) });
                assert_eq!(jnt_axis[i][j], unsafe { *model.ffi().jnt_axis.add(i * 3 + j) });
            }
            for j in 0..2 {
                assert_eq!(jnt_range[i][j], unsafe { *model.ffi().jnt_range.add(i * 2 + j) });
            }
        }

        // "rod" has axis="0 1 0", range="0 1"
        let rod = model.joint("rod").unwrap();
        assert_eq!(&jnt_axis[rod.id][..], &[0.0, 1.0, 0.0]);
        assert_eq!(&jnt_range[rod.id][..], &[0.0, 1.0]);
    }

    /// Verifies [force]-cast for view fields with enum types: joint view r#type,
    /// geom view r#type, sensor view r#type + objtype, actuator view trntype + biastype.
    /// Tests that the view_creator! macro correctly passes [force] tokens through.
    #[test]
    fn test_force_cast_view_enum_fields() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();

        // Joint type via view
        let rod_info = model.joint("rod").unwrap();
        let rod_view = rod_info.view(&model);
        assert_eq!(rod_view.r#type[0], MjtJoint::mjJNT_SLIDE);
        assert!(rod_view.limited[0]);

        // Geom type via view
        let ball2_info = model.geom("ball2").unwrap();
        let ball2_view = ball2_info.view(&model);
        assert_eq!(ball2_view.r#type[0], MjtGeom::mjGEOM_SPHERE);

        // Sensor type via view
        let touch_info = model.sensor("touch").unwrap();
        let touch_view = touch_info.view(&model);
        assert_eq!(touch_view.r#type[0], MjtSensor::mjSENS_TOUCH);
        assert_eq!(touch_view.objtype[0], MjtObj::mjOBJ_SITE);

        // Actuator types via view
        let slider_info = model.actuator("slider").unwrap();
        let slider_view = slider_info.view(&model);
        assert_eq!(slider_view.trntype[0], MjtTrn::mjTRN_JOINT);
        assert_eq!(slider_view.biastype[0], MjtBias::mjBIAS_AFFINE);
        assert_eq!(slider_view.gaintype[0], MjtGain::mjGAIN_FIXED);
        assert!(slider_view.ctrllimited[0]);

        // Mutable enum roundtrip via view
        let mut slider_view_mut = slider_info.view_mut(&mut model);
        slider_view_mut.biastype[0] = MjtBias::mjBIAS_NONE;
        let slider_view2 = slider_info.view(&model);
        assert_eq!(slider_view2.biastype[0], MjtBias::mjBIAS_NONE);
    }

    /// Verifies mutable model-array roundtrip via info views.
    /// Tests that mutations through `view_mut` are reflected in the flat arrays and FFI.
    #[test]
    fn test_model_view_mut_roundtrip() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();

        // Mutate body_pos via mutable info view.
        let ball2_info = model.body("ball2").unwrap();
        let ball2_id = ball2_info.id;
        let orig_pos = model.body_pos()[ball2_id];
        assert_eq!(orig_pos, [0.5, 0.0, 0.0]);

        {
            let mut body_view = ball2_info.view_mut(&mut model);
            body_view.pos.copy_from_slice(&[99.0, 88.0, 77.0]);
        }
        assert_eq!(model.body_pos()[ball2_id], [99.0, 88.0, 77.0]);

        // Verify FFI side
        for j in 0..3 {
            let ffi_val = unsafe { *model.ffi().body_pos.add(ball2_id * 3 + j) };
            assert_eq!(ffi_val, [99.0, 88.0, 77.0][j]);
        }

        // Mutate geom_rgba via mutable info view.
        let gs_info = model.geom("green_sphere").unwrap();
        let gs_id = gs_info.id;
        {
            let mut geom_view = gs_info.view_mut(&mut model);
            geom_view.rgba.copy_from_slice(&[1.0f32, 0.0, 0.0, 0.5]);
        }
        assert_eq!(model.geom_rgba()[gs_id], [1.0f32, 0.0, 0.0, 0.5]);
        for j in 0..4 {
            assert_eq!(unsafe { *model.ffi().geom_rgba.add(gs_id * 4 + j) }, [1.0f32, 0.0, 0.0, 0.5][j]);
        }
    }

    /// Verifies [force]-cast sublen_dep variant in model: key_qpos, key_qvel, key_act, key_ctrl.
    /// These have variable inner dimensions dependent on nq, nv, na, nu.
    #[test]
    fn test_force_cast_sublen_dep_key_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let nkey = model.ffi().nkey as usize;
        let nq = model.ffi().nq as usize;
        let nv = model.ffi().nv as usize;
        let na = model.ffi().na as usize;
        let nu = model.ffi().nu as usize;

        assert!(nkey >= 2, "EXAMPLE_MODEL must have at least 2 keyframes");

        let key_qpos = model.key_qpos();
        let key_qvel = model.key_qvel();
        let key_act = model.key_act();
        let key_ctrl = model.key_ctrl();

        // Total flat length must be nkey * inner_dim
        assert_eq!(key_qpos.len(), nkey * nq);
        assert_eq!(key_qvel.len(), nkey * nv);
        assert_eq!(key_act.len(), nkey * na);
        assert_eq!(key_ctrl.len(), nkey * nu);

        // Cross-validate with FFI
        for i in 0..(nkey * nq) {
            assert_eq!(key_qpos[i], unsafe { *model.ffi().key_qpos.add(i) });
        }
        for i in 0..(nkey * nv) {
            assert_eq!(key_qvel[i], unsafe { *model.ffi().key_qvel.add(i) });
        }
        for i in 0..(nkey * nu) {
            assert_eq!(key_ctrl[i], unsafe { *model.ffi().key_ctrl.add(i) });
        }
    }

    /// Tests empty model edge case: model with no optional objects should return
    /// empty slices for all force-cast enum/bool/array fields.
    #[test]
    fn test_force_cast_minimal_model_edge_case() {
        let xml = "<mujoco><worldbody><body><joint type='free'/><geom size='0.1'/></body></worldbody></mujoco>";
        let model = MjModel::from_xml_string(xml).unwrap();

        // No equalities, no tendons, no actuators, no sensors, no cameras, no lights, no textures, no materials
        assert_eq!(model.ffi().neq, 0);
        assert_eq!(model.ffi().ntendon, 0);
        assert_eq!(model.ffi().nu, 0);
        assert_eq!(model.ffi().nsensor, 0);
        assert_eq!(model.ffi().ncam, 0);
        assert_eq!(model.ffi().ntex, 0);
        assert_eq!(model.ffi().nmat, 0);

        // All force-cast slices should be empty
        assert!(model.eq_type().is_empty());
        assert!(model.eq_active0().is_empty());
        assert!(model.tendon_limited().is_empty());
        assert!(model.tendon_rgba().is_empty());
        assert!(model.actuator_trntype().is_empty());
        assert!(model.actuator_ctrllimited().is_empty());
        assert!(model.sensor_type().is_empty());
        assert!(model.cam_mode().is_empty());
        assert!(model.cam_resolution().is_empty());
        assert!(model.tex_type().is_empty());
        assert!(model.mat_texuniform().is_empty());
        assert!(model.mat_rgba().is_empty());

        // But body/geom/joint arrays should work (always have at least world body)
        let nbody = model.ffi().nbody as usize;
        assert!(nbody >= 2);
        assert_eq!(model.body_pos().len(), nbody);
        assert_eq!(model.body_sameframe().len(), nbody);
        assert_eq!(model.jnt_type().len(), model.ffi().njnt as usize);
        assert_eq!(model.geom_type().len(), model.ffi().ngeom as usize);
    }

    /// Verifies [force]-cast pair arrays: pair_solref (&[[MjtNum; mjNREF]]),
    /// pair_friction (&[[MjtNum; 5]]).
    #[test]
    fn test_force_cast_pair_model_arrays() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let npair = model.ffi().npair as usize;

        if npair == 0 {
            return;
        }

        let pair_solref = model.pair_solref();
        let pair_friction = model.pair_friction();
        let pair_solimp = model.pair_solimp();

        assert_eq!(pair_solref.len(), npair);
        assert_eq!(pair_friction.len(), npair);
        assert_eq!(pair_solimp.len(), npair);

        let nref = mjNREF as usize;
        let nimp = mjNIMP as usize;

        for i in 0..npair {
            for j in 0..nref {
                assert_eq!(pair_solref[i][j], unsafe { *model.ffi().pair_solref.add(i * nref + j) });
            }
            for j in 0..5 {
                assert_eq!(pair_friction[i][j], unsafe { *model.ffi().pair_friction.add(i * 5 + j) });
            }
            for j in 0..nimp {
                assert_eq!(pair_solimp[i][j], unsafe { *model.ffi().pair_solimp.add(i * nimp + j) });
            }
        }
    }

    /// Verifies [force]-cast non-aliasing: adjacent joints' solver ref slices
    /// point to different memory.
    #[test]
    fn test_force_cast_model_non_aliasing() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let njnt = model.ffi().njnt as usize;

        if njnt < 2 {
            return;
        }

        let jnt_solref = model.jnt_solref();
        let jnt_type = model.jnt_type();

        // Adjacent elements must not alias
        assert_ne!(jnt_solref[0].as_ptr(), jnt_solref[1].as_ptr());
        assert_ne!(std::ptr::addr_of!(jnt_type[0]), std::ptr::addr_of!(jnt_type[1]));

        // Stride must be exactly mjNREF elements
        let stride = jnt_solref.as_flattened().element_offset(&jnt_solref[1][0]).unwrap();
        assert_eq!(stride, mjNREF as usize,
            "jnt_solref stride must be mjNREF={}", mjNREF);
    }

    /// Model with 2 mocap bodies and 2 keyframes carrying specific mocap data.
    /// This lets us verify key_mpos and key_mquat array-slice strides and values.
    const MOCAP_MODEL: &str = stringify!(
        <mujoco>
            <worldbody>
                <body name="mocap1" mocap="true" pos="0 0 0">
                    <geom type="sphere" size="0.05" contype="0" conaffinity="0"/>
                </body>
                <body name="mocap2" mocap="true" pos="1 0 0">
                    <geom type="sphere" size="0.05" contype="0" conaffinity="0"/>
                </body>
                <geom type="plane" size="5 5 0.1"/>
            </worldbody>
            <keyframe>
                <key name="k0"
                     mpos="1.0 2.0 3.0  4.0 5.0 6.0"
                     mquat="0.5 0.5 0.5 0.5  1.0 0.0 0.0 0.0"/>
                <key name="k1"
                     mpos="10.0 20.0 30.0  40.0 50.0 60.0"
                     mquat="0.0 0.0 0.0 1.0  0.0 1.0 0.0 0.0"/>
            </keyframe>
        </mujoco>
    );

    /// Test that `key_mpos` returns the correct slice length and exact values
    /// for a model with 2 mocap bodies and 2 keyframes.
    #[test]
    fn test_key_mpos() {
        let model = MjModel::from_xml_string(MOCAP_MODEL).unwrap();
        let nkey = model.ffi().nkey as usize;
        let nmocap = model.ffi().nmocap as usize;

        assert_eq!(nkey, 2, "expected 2 keyframes");
        assert_eq!(nmocap, 2, "expected 2 mocap bodies");

        let mpos = model.key_mpos();
        assert_eq!(mpos.len(), nkey * nmocap * 3,
            "key_mpos length must be nkey * nmocap * 3 = {}", nkey * nmocap * 3);

        // Keyframe 0: mocap1 at (1,2,3), mocap2 at (4,5,6)
        let k0 = &mpos[..nmocap * 3];
        let expected_k0: &[f64] = &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
        assert_eq!(k0.len(), expected_k0.len());
        for (&a, &b) in k0.iter().zip(expected_k0.iter()) {
            assert_relative_eq!(a, b, epsilon = 1e-10);
        }

        // Keyframe 1: mocap1 at (10,20,30), mocap2 at (40,50,60)
        let k1 = &mpos[nmocap * 3..];
        let expected_k1: &[f64] = &[10.0, 20.0, 30.0, 40.0, 50.0, 60.0];
        assert_eq!(k1.len(), expected_k1.len());
        for (&a, &b) in k1.iter().zip(expected_k1.iter()) {
            assert_relative_eq!(a, b, epsilon = 1e-10);
        }
    }

    /// Test that `key_mquat` returns the correct slice length and exact values
    /// for a model with 2 mocap bodies and 2 keyframes.
    #[test]
    fn test_key_mquat() {
        let model = MjModel::from_xml_string(MOCAP_MODEL).unwrap();
        let nkey = model.ffi().nkey as usize;
        let nmocap = model.ffi().nmocap as usize;

        assert_eq!(nkey, 2, "expected 2 keyframes");
        assert_eq!(nmocap, 2, "expected 2 mocap bodies");

        let mquat = model.key_mquat();
        assert_eq!(mquat.len(), nkey * nmocap * 4,
            "key_mquat length must be nkey * nmocap * 4 = {}", nkey * nmocap * 4);

        // Keyframe 0: mocap1 quat (0.5,0.5,0.5,0.5), mocap2 quat (1,0,0,0)
        let k0 = &mquat[..nmocap * 4];
        let expected_k0: &[f64] = &[0.5, 0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.0];
        assert_eq!(k0.len(), expected_k0.len());
        for (&a, &b) in k0.iter().zip(expected_k0.iter()) {
            assert_relative_eq!(a, b, epsilon = 1e-10);
        }

        // Keyframe 1: mocap1 quat (0,0,0,1), mocap2 quat (0,1,0,0)
        let k1 = &mquat[nmocap * 4..];
        let expected_k1: &[f64] = &[0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0];
        assert_eq!(k1.len(), expected_k1.len());
        for (&a, &b) in k1.iter().zip(expected_k1.iter()) {
            assert_relative_eq!(a, b, epsilon = 1e-10);
        }
    }

    /// Test that key_mpos is accessible through the key view as well,
    /// and that both paths yield the same data.
    #[test]
    fn test_key_mpos_view_consistency() {
        let model = MjModel::from_xml_string(MOCAP_MODEL).unwrap();
        let nmocap = model.ffi().nmocap as usize;

        let info_k0 = model.key("k0").unwrap();
        let view_k0 = info_k0.view(&model);

        // key view mpos slice should equal array accessor key_mpos[0..nmocap*3]
        let array_k0 = &model.key_mpos()[..nmocap * 3];
        assert_eq!(
            &view_k0.mpos[..nmocap * 3], array_k0,
            "key view mpos and key_mpos array accessor must return identical data"
        );

        let info_k1 = model.key("k1").unwrap();
        let view_k1 = info_k1.view(&model);
        let array_k1 = &model.key_mpos()[nmocap * 3..];
        assert_eq!(
            &view_k1.mpos[..nmocap * 3], array_k1,
            "key view mpos and key_mpos array accessor must return identical data for key 1"
        );
    }

    /// Test that key_mpos/key_mquat return empty slices for models with no mocap bodies.
    #[test]
    fn test_key_mpos_mquat_no_mocap() {
        // EXAMPLE_MODEL has keyframes but no mocap bodies
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        assert_eq!(model.ffi().nmocap, 0, "EXAMPLE_MODEL should have no mocap bodies");
        assert!(model.ffi().nkey > 0, "EXAMPLE_MODEL should have keyframes");

        assert_eq!(model.key_mpos().len(), 0,
            "key_mpos must be empty when nmocap == 0");
        assert_eq!(model.key_mquat().len(), 0,
            "key_mquat must be empty when nmocap == 0");
    }

    /// Loading invalid XML must return an Err whose message is non-empty.
    #[test]
    fn test_from_xml_string_invalid() {
        let result = MjModel::from_xml_string("<this is not valid mujoco xml>");
        assert!(result.is_err(), "loading invalid XML must return Err");
        let msg = result.unwrap_err().to_string();
        assert!(!msg.is_empty(), "error message must not be empty for invalid XML");
    }

    /// Verifies the new mesh view fields added in MuJoCo 3.8.0:
    /// read-only index fields (`normaladr`, `normalnum`, etc.) have length 1,
    /// and the read-write fields (`scale`, `pos`, `quat`) have the right length
    /// and survive a roundtrip write.
    #[test]
    fn test_mesh_view_new_fields() {
        const MESH_MODEL: &str = "<mujoco>\
          <asset>\
            <mesh name=\"cube\" vertex=\"-0.5 -0.5 -0.5  0.5 -0.5 -0.5  -0.5  0.5 -0.5  0.5  0.5 -0.5  \
                                         -0.5 -0.5  0.5  0.5 -0.5  0.5  -0.5  0.5  0.5  0.5  0.5  0.5\"/>\
          </asset>\
          <worldbody>\
            <geom type=\"mesh\" mesh=\"cube\"/>\
          </worldbody>\
        </mujoco>";

        let mut model = MjModel::from_xml_string(MESH_MODEL).unwrap();
        let mesh_info = model.mesh("cube").unwrap();

        let view = mesh_info.view(&model);

        /* Verify field dimensions for read-write fields */
        assert_eq!(view.scale.len(), 3);
        assert_eq!(view.pos.len(), 3);
        assert_eq!(view.quat.len(), 4);

        /* Verify field dimensions for read-only index fields */
        assert_eq!(view.normaladr.len(), 1);
        assert_eq!(view.normalnum.len(), 1);
        assert_eq!(view.texcoordnum.len(), 1);
        assert_eq!(view.bvhadr.len(), 1);
        assert_eq!(view.bvhnum.len(), 1);
        assert_eq!(view.octadr.len(), 1);
        assert_eq!(view.octnum.len(), 1);
        assert_eq!(view.pathadr.len(), 1);
        assert_eq!(view.polynum.len(), 1);
        assert_eq!(view.polyadr.len(), 1);

        /* Verify write-read roundtrip for scale */
        let mut view_mut = mesh_info.view_mut(&mut model);
        view_mut.scale[0] = 2.0;
        view_mut.scale[1] = 3.0;
        view_mut.scale[2] = 4.0;

        let view2 = mesh_info.view(&model);
        assert_eq!(view2.scale[0], 2.0);
        assert_eq!(view2.scale[1], 3.0);
        assert_eq!(view2.scale[2], 4.0);
    }

    /// Verifies that `flex_cellnum`, `flex_stiffnessadr`, and `flex_bendingadr`
    /// return empty slices when the model contains no flex bodies.
    #[test]
    fn test_flex_array_slices_empty_for_non_flex_model() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        assert_eq!(model.ffi().nflex, 0);
        assert_eq!(model.flex_cellnum().len(), 0);
        assert_eq!(model.flex_stiffnessadr().len(), 0);
        assert_eq!(model.flex_bendingadr().len(), 0);
    }

    /// Tests the wrapper of `mj_maxContact` ([`MjModel::max_contacts`]).
    #[test]
    fn test_max_contacts() {
        let model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        let geom1 = model.name_to_id(MjtObj::mjOBJ_GEOM, "green_sphere").unwrap();
        let geom2 = model.name_to_id(MjtObj::mjOBJ_GEOM, "ball2").unwrap();

        let mc = model.max_contacts(geom1, geom2, None);  // pull margin from model.
        assert_eq!(mc, 1);

        let mc = model.max_contacts(geom1, geom2, Some(false));
        assert_eq!(mc, 1);

        // Spheres always have one contact, regardless of margin.
        let mc = model.max_contacts(geom1, geom2, Some(true));
        assert_eq!(mc, 1);

        // Test invalid geom index.
        assert!( model.try_max_contacts(999, geom2, Some(true)).is_err());
    }

    /// Drives the generated sanitizer probes over every dynamic array of |MjModel|. See the
    /// matching test on |MjData| for what the sanitizers catch here.
    #[test]
    fn test_probe_dynamic_arrays_stays_in_bounds() {
        let mut model = MjModel::from_xml_string(EXAMPLE_MODEL).unwrap();
        assert!(model.ffi().nbody > 1, "the model must have bodies for the probe to mean anything");
        model.probe_dynamic_arrays();

        // SAFETY: no accessor of this block needs a pipeline stage; the compiler fills the model.
        unsafe { model.probe_dynamic_arrays_unsafe() };
    }
}