whiteout/

m2.rs

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2026 Fernando Sahmkow
// AUTOGENERATED by tools/codegen/emit_rust.py — do not edit.
// Regenerate via:  python -m tools.codegen.codegen m2 --backend rust

#![allow(clippy::too_many_arguments)]

// Which of these a module needs depends on its shapes; the modules that
// have no span accessors would otherwise trip the unused-import lint.
#[allow(unused_imports)]
use crate::support::{BorrowedSlice, Bytes};

#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum InterpolationType {
    None = 0,
    Linear = 1,
    Bezier = 2,
    Hermite = 3,
}

impl TryFrom<i32> for InterpolationType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(InterpolationType::None),
            1 => Ok(InterpolationType::Linear),
            2 => Ok(InterpolationType::Bezier),
            3 => Ok(InterpolationType::Hermite),
            other => Err(crate::Error::UnknownEnum {
                name: "InterpolationType",
                value: other,
            }),
        }
    }
}

/// Bit flags. Combine with `|`, test with [`GlobalFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct GlobalFlag(pub i32);

impl GlobalFlag {
    pub const NONE: Self = Self(0);
    pub const TILT_X: Self = Self(1);
    pub const TILT_Y: Self = Self(2);
    pub const ADD_BACK_REFERENCES: Self = Self(4);
    pub const USE_TEXTURE_COMBINER_COMBOS: Self = Self(8);
    pub const IS_CAMERA: Self = Self(16);
    pub const LOAD_PHYSICS_DATA: Self = Self(32);
    pub const UNK_0X_80: Self = Self(128);
    pub const UNK_0X_100: Self = Self(256);
    pub const NEW_PARTICLE_RECORD: Self = Self(512);
    pub const UNK_0X_400: Self = Self(1024);
    pub const TEXTURE_TRANSFORMS_USES_BONE_SEQUENCES: Self = Self(2048);
    pub const UNK_0X_1000: Self = Self(4096);
    pub const CHUNKED_ANIM_FILES: Self = Self(8192);
    pub const UPGRADED_FORMAT: Self = Self(2097152);

    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    #[inline]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl core::ops::BitOr for GlobalFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitAnd for GlobalFlag {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::Not for GlobalFlag {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl core::fmt::Debug for GlobalFlag {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "GlobalFlag({:#x})", self.0)
    }
}

/// Bit flags. Combine with `|`, test with [`SequenceFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct SequenceFlag(pub i32);

impl SequenceFlag {
    pub const NONE: Self = Self(0);
    pub const TILT_IN: Self = Self(1);
    pub const TILT_OUT: Self = Self(2);
    pub const TILT_FIXED: Self = Self(4);
    pub const LOOPING: Self = Self(32);
    pub const IS_ALIAS: Self = Self(64);
    pub const ANIMATED_SETUP: Self = Self(128);
    pub const STORED_ANIMATED: Self = Self(256);
    pub const ENABLE_COMPOSITE: Self = Self(512);

    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    #[inline]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl core::ops::BitOr for SequenceFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitAnd for SequenceFlag {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::Not for SequenceFlag {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl core::fmt::Debug for SequenceFlag {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "SequenceFlag({:#x})", self.0)
    }
}

/// Bit flags. Combine with `|`, test with [`BoneFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct BoneFlag(pub i32);

impl BoneFlag {
    pub const NONE: Self = Self(0);
    pub const IGNORE_PARENT_TRANSLATE: Self = Self(1);
    pub const IGNORE_PARENT_SCALE: Self = Self(2);
    pub const IGNORE_PARENT_ROTATION: Self = Self(4);
    pub const SPHERICAL_BILLBOARD: Self = Self(8);
    pub const CYLINDRICAL_BILLBOARD_X: Self = Self(16);
    pub const CYLINDRICAL_BILLBOARD_Y: Self = Self(32);
    pub const CYLINDRICAL_BILLBOARD_Z: Self = Self(64);
    pub const TRANSFORMED: Self = Self(512);
    pub const KINEMATIC: Self = Self(1024);
    pub const HELMET_ANIM_SCALED: Self = Self(4096);

    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    #[inline]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl core::ops::BitOr for BoneFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitAnd for BoneFlag {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::Not for BoneFlag {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl core::fmt::Debug for BoneFlag {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "BoneFlag({:#x})", self.0)
    }
}

/// Bit flags. Combine with `|`, test with [`MaterialFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct MaterialFlag(pub i32);

impl MaterialFlag {
    pub const NONE: Self = Self(0);
    pub const UNLIT: Self = Self(1);
    pub const UNFOGGED: Self = Self(2);
    pub const TWO_SIDED: Self = Self(4);
    pub const DEPTH_TEST: Self = Self(8);
    pub const DEPTH_WRITE: Self = Self(16);
    pub const NO_ALPHA_COMPOSITE: Self = Self(2048);

    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    #[inline]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl core::ops::BitOr for MaterialFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitAnd for MaterialFlag {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::Not for MaterialFlag {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl core::fmt::Debug for MaterialFlag {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "MaterialFlag({:#x})", self.0)
    }
}

#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ParticleEmitterType {
    Plane = 1,
    Sphere = 2,
    Spline = 3,
    Bone = 4,
}

impl TryFrom<i32> for ParticleEmitterType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            1 => Ok(ParticleEmitterType::Plane),
            2 => Ok(ParticleEmitterType::Sphere),
            3 => Ok(ParticleEmitterType::Spline),
            4 => Ok(ParticleEmitterType::Bone),
            other => Err(crate::Error::UnknownEnum {
                name: "ParticleEmitterType",
                value: other,
            }),
        }
    }
}

#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ParticleBlending {
    Opaque = 0,
    AlphaBlend = 1,
    Additive = 2,
    AlphaTest = 3,
    AdditiveAlphaTest = 4,
}

impl TryFrom<i32> for ParticleBlending {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(ParticleBlending::Opaque),
            1 => Ok(ParticleBlending::AlphaBlend),
            2 => Ok(ParticleBlending::Additive),
            3 => Ok(ParticleBlending::AlphaTest),
            4 => Ok(ParticleBlending::AdditiveAlphaTest),
            other => Err(crate::Error::UnknownEnum {
                name: "ParticleBlending",
                value: other,
            }),
        }
    }
}

/// Bit flags. Combine with `|`, test with [`ParticleFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct ParticleFlag(pub i32);

impl ParticleFlag {
    pub const NONE: Self = Self(0);
    pub const UNLIT: Self = Self(1);
    pub const SORT_PARTICLES: Self = Self(2);
    pub const VELOCITY_ORIENT: Self = Self(4);
    pub const UNFOGGED: Self = Self(8);
    pub const WORLD_SPACE: Self = Self(16);
    pub const INHERIT_BONE_SCALE: Self = Self(32);
    pub const INHERIT_VELOCITY: Self = Self(64);
    pub const IMPLOSION_FILTER: Self = Self(128);
    pub const HEMISPHERE_UP_DIRECTION: Self = Self(256);
    pub const NEGATE_SPIN_RANDOM: Self = Self(512);
    pub const CLAMP_TAIL_TO_AGE: Self = Self(1024);
    pub const INHERIT_POSITION: Self = Self(2048);
    pub const XY_QUAD: Self = Self(4096);
    pub const PROJECT_PARTICLE: Self = Self(8192);
    pub const FOLLOW_POSITION: Self = Self(16384);
    pub const SQUIRT: Self = Self(32768);
    pub const CHOOSE_RANDOM_TEXTURE: Self = Self(65536);
    pub const HEAD_STYLE: Self = Self(131072);
    pub const TAIL_STYLE: Self = Self(262144);
    pub const UNSCALED_SIZE_VARIATION: Self = Self(524288);
    pub const REFRACTION: Self = Self(1048576);
    pub const RAND_FLIPBOOK_START: Self = Self(2097152);
    pub const UNK_0X_400000: Self = Self(4194304);
    pub const COMPRESSED_GRAVITY: Self = Self(8388608);
    pub const BONE_GENERATOR_BONE: Self = Self(16777216);
    pub const NO_GLOBAL_VIEW_SCALE: Self = Self(33554432);
    pub const LOD_IGNORE_DISTANCE: Self = Self(67108864);
    pub const OFFSET_HEAD_BY_SPIN: Self = Self(134217728);
    pub const MULTI_TEXTURE: Self = Self(268435456);
    pub const MULTITEX_USE_MODX_4: Self = Self(536870912);
    pub const MULTITEX_USE_3_COLORS: Self = Self(1073741824);
    pub const DYNAMIC_WIND: Self = Self(-2147483648);

    #[inline]
    pub const fn contains(self, other: Self) -> bool {
        (self.0 & other.0) == other.0
    }

    #[inline]
    pub const fn is_empty(self) -> bool {
        self.0 == 0
    }
}

impl core::ops::BitOr for ParticleFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl core::ops::BitAnd for ParticleFlag {
    type Output = Self;
    #[inline]
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl core::ops::Not for ParticleFlag {
    type Output = Self;
    #[inline]
    fn not(self) -> Self {
        Self(!self.0)
    }
}

impl core::fmt::Debug for ParticleFlag {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "ParticleFlag({:#x})", self.0)
    }
}

/// How the client drives a body — the value stored in BODY is inverted relative to Domino's own `dmBodyType`.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PhysicsBodyType {
    /// Animation-driven collider. Becomes `dmBodyType` 1; the client keeps it glued to its bone and the simulation only reads it.
    Kinematic = 0,
    /// Simulated. Becomes `dmBodyType` 0 and gets its bone transform written back every frame. These are the cloth/tassel segments.
    Dynamic = 1,
}

impl TryFrom<i32> for PhysicsBodyType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(PhysicsBodyType::Kinematic),
            1 => Ok(PhysicsBodyType::Dynamic),
            other => Err(crate::Error::UnknownEnum {
                name: "PhysicsBodyType",
                value: other,
            }),
        }
    }
}

/// Which shape chunk a PhysicsShape indexes into.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PhysicsShapeType {
    /// BOXS
    Box = 0,
    /// CAPS
    Capsule = 1,
    /// SPHS
    Sphere = 2,
    /// PLYT, version 3+
    Polytope = 3,
}

impl TryFrom<i32> for PhysicsShapeType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(PhysicsShapeType::Box),
            1 => Ok(PhysicsShapeType::Capsule),
            2 => Ok(PhysicsShapeType::Sphere),
            3 => Ok(PhysicsShapeType::Polytope),
            other => Err(crate::Error::UnknownEnum {
                name: "PhysicsShapeType",
                value: other,
            }),
        }
    }
}

/// Which joint chunk a PhysicsJoint indexes into.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PhysicsJointType {
    /// SPHJ
    Spherical = 0,
    /// SHOJ / SHJ2
    Shoulder = 1,
    /// WELJ / WLJ2 / WLJ3
    Weld = 2,
    /// REVJ / REV2, version 2+
    Revolute = 3,
    /// PRSJ / PRS2, version 2+
    Prismatic = 4,
    /// DSTJ, version 2+
    Distance = 5,
}

impl TryFrom<i32> for PhysicsJointType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(PhysicsJointType::Spherical),
            1 => Ok(PhysicsJointType::Shoulder),
            2 => Ok(PhysicsJointType::Weld),
            3 => Ok(PhysicsJointType::Revolute),
            4 => Ok(PhysicsJointType::Prismatic),
            5 => Ok(PhysicsJointType::Distance),
            other => Err(crate::Error::UnknownEnum {
                name: "PhysicsJointType",
                value: other,
            }),
        }
    }
}

pub struct CompatQuaternion {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2CompatQuaternion>,
}

impl Drop for CompatQuaternion {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2CompatQuaternion_delete(self.raw.as_ptr()) }
    }
}

impl CompatQuaternion {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2CompatQuaternion) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CompatQuaternion { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for CompatQuaternion {}

impl core::fmt::Debug for CompatQuaternion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("CompatQuaternion").finish_non_exhaustive()
    }
}

impl CompatQuaternion {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2CompatQuaternion_new();
            Self::from_raw(raw).expect("native CompatQuaternion allocation failed")
        }
    }
}

impl Default for CompatQuaternion {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ColorBGRA {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ColorBGRA>,
}

impl Drop for ColorBGRA {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ColorBGRA_delete(self.raw.as_ptr()) }
    }
}

impl ColorBGRA {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ColorBGRA) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ColorBGRA { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ColorBGRA {}

impl core::fmt::Debug for ColorBGRA {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ColorBGRA").finish_non_exhaustive()
    }
}

impl ColorBGRA {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ColorBGRA_new();
            Self::from_raw(raw).expect("native ColorBGRA allocation failed")
        }
    }
}

impl Default for ColorBGRA {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Extent {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Extent>,
}

impl Drop for Extent {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Extent_delete(self.raw.as_ptr()) }
    }
}

impl Extent {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Extent) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Extent { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Extent {}

impl core::fmt::Debug for Extent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Extent").finish_non_exhaustive()
    }
}

impl Extent {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Extent_new();
            Self::from_raw(raw).expect("native Extent allocation failed")
        }
    }

    pub fn minimum(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Extent_get_minimum(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_minimum(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Extent_set_minimum(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn maximum(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Extent_get_maximum(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_maximum(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Extent_set_maximum(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn sphere_radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Extent_get_sphereRadius(self.raw.as_ptr()) }
    }

    pub fn set_sphere_radius(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Extent_set_sphereRadius(self.raw.as_ptr(), value) }
    }
}

impl Default for Extent {
    fn default() -> Self {
        Self::new()
    }
}

/// One sequence's slice of a key array, as the file writes it: a count and an offset into whichever file holds that sequence's keys.
///
/// Kept only by a lazily parsed model (Parser::setLazyAnimations), which leaves the sub-arrays of externally-stored sequences empty until loadSequence() reads their `.anim` sibling. Nothing else needs it: an eager parse consumes the reference on the spot.
pub struct KeySpanRef {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2KeySpanRef>,
}

impl Drop for KeySpanRef {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2KeySpanRef_delete(self.raw.as_ptr()) }
    }
}

impl KeySpanRef {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2KeySpanRef) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| KeySpanRef { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for KeySpanRef {}

impl core::fmt::Debug for KeySpanRef {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("KeySpanRef").finish_non_exhaustive()
    }
}

impl KeySpanRef {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2KeySpanRef_new();
            Self::from_raw(raw).expect("native KeySpanRef allocation failed")
        }
    }

    pub fn count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2KeySpanRef_get_count(self.raw.as_ptr()) }
    }

    pub fn set_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2KeySpanRef_set_count(self.raw.as_ptr(), value) }
    }

    pub fn offset(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2KeySpanRef_get_offset(self.raw.as_ptr()) }
    }

    pub fn set_offset(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2KeySpanRef_set_offset(self.raw.as_ptr(), value) }
    }
}

impl Default for KeySpanRef {
    fn default() -> Self {
        Self::new()
    }
}

pub struct AnimationTrackBase {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackBase>,
}

impl Drop for AnimationTrackBase {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackBase_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackBase {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2AnimationTrackBase) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackBase { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackBase {}

impl core::fmt::Debug for AnimationTrackBase {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackBase").finish_non_exhaustive()
    }
}

impl AnimationTrackBase {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackBase_new();
            Self::from_raw(raw).expect("native AnimationTrackBase allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2AnimationTrackBase_get_interpolationType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackBase_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackBase_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackBase_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackBase_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackBase_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackBase_resize_timestamps(self.raw.as_ptr(), count) }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackBase_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackBase {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ParticleEmitterExtension {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ParticleEmitterExtension>,
}

impl Drop for ParticleEmitterExtension {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ParticleEmitterExtension_delete(self.raw.as_ptr()) }
    }
}

impl ParticleEmitterExtension {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2ParticleEmitterExtension,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleEmitterExtension { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ParticleEmitterExtension {}

impl core::fmt::Debug for ParticleEmitterExtension {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ParticleEmitterExtension")
            .finish_non_exhaustive()
    }
}

impl ParticleEmitterExtension {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ParticleEmitterExtension_new();
            Self::from_raw(raw).expect("native ParticleEmitterExtension allocation failed")
        }
    }

    pub fn z_source(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitterExtension_get_zSource(self.raw.as_ptr()) }
    }

    pub fn set_z_source(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitterExtension_set_zSource(self.raw.as_ptr(), value) }
    }

    pub fn color_mult(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitterExtension_get_colorMult(self.raw.as_ptr()) }
    }

    pub fn set_color_mult(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitterExtension_set_colorMult(self.raw.as_ptr(), value)
        }
    }

    pub fn alpha_mult(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitterExtension_get_alphaMult(self.raw.as_ptr()) }
    }

    pub fn set_alpha_mult(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitterExtension_set_alphaMult(self.raw.as_ptr(), value)
        }
    }
}

impl Default for ParticleEmitterExtension {
    fn default() -> Self {
        Self::new()
    }
}

pub struct LodProfile {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2LodProfile>,
}

impl Drop for LodProfile {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2LodProfile_delete(self.raw.as_ptr()) }
    }
}

impl LodProfile {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2LodProfile) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| LodProfile { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for LodProfile {}

impl core::fmt::Debug for LodProfile {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("LodProfile").finish_non_exhaustive()
    }
}

impl LodProfile {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2LodProfile_new();
            Self::from_raw(raw).expect("native LodProfile allocation failed")
        }
    }

    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn num_lod_levels(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_numLodLevels(self.raw.as_ptr()) }
    }

    pub fn set_num_lod_levels(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_numLodLevels(self.raw.as_ptr(), value) }
    }

    pub fn lod_distance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_lodDistance(self.raw.as_ptr()) }
    }

    pub fn set_lod_distance(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_lodDistance(self.raw.as_ptr(), value) }
    }

    /// Per-LOD particle bone mask index. Only four are stored, but the client drives up to eight LOD levels: it copies [0..3] into its first four slots and then replicates entry [3] into slots 4..7.
    /// Number of elements — a fixed-size C++ array.
    pub const fn particle_bone_lod_len() -> usize {
        4
    }

    /// # Panics
    /// If `index >= 4`, matching Rust slice indexing.
    pub fn particle_bone_lod(&self, index: usize) -> u8 {
        assert!(
            index < 4,
            "particle_bone_lod index {index} out of range (len 4)"
        );
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_particleBoneLod_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 4`.
    pub fn set_particle_bone_lod(&mut self, index: usize, value: u8) {
        assert!(
            index < 4,
            "particle_bone_lod index {index} out of range (len 4)"
        );
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2LodProfile_set_particleBoneLod_at(self.raw.as_ptr(), index, value)
        }
    }

    /// Fixed-point LOD scale, applied as `lodScaleRaw / 2048.0` and only when `flags & 0x08` is set (otherwise the client uses 1.0). This is the pair of bytes previously read as `reserved0` + `lodFlags`; reading it as a u16 explains why the high byte looked like a mirror of flags bit 3, since 0x0800 / 2048 == 1.0.
    pub fn lod_scale_raw(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_lodScaleRaw(self.raw.as_ptr()) }
    }

    pub fn set_lod_scale_raw(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_lodScaleRaw(self.raw.as_ptr(), value) }
    }

    pub fn lod_batch_count(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_lodBatchCount(self.raw.as_ptr()) }
    }

    pub fn set_lod_batch_count(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_lodBatchCount(self.raw.as_ptr(), value) }
    }

    pub fn reserved_1(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_get_reserved1(self.raw.as_ptr()) }
    }

    pub fn set_reserved_1(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2LodProfile_set_reserved1(self.raw.as_ptr(), value) }
    }
}

impl Default for LodProfile {
    fn default() -> Self {
        Self::new()
    }
}

pub struct WaterfallData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2WaterfallData>,
}

impl Drop for WaterfallData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2WaterfallData_delete(self.raw.as_ptr()) }
    }
}

impl WaterfallData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2WaterfallData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| WaterfallData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for WaterfallData {}

impl core::fmt::Debug for WaterfallData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("WaterfallData").finish_non_exhaustive()
    }
}

impl WaterfallData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2WaterfallData_new();
            Self::from_raw(raw).expect("native WaterfallData allocation failed")
        }
    }

    pub fn bump_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_bumpScale(self.raw.as_ptr()) }
    }

    pub fn set_bump_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_bumpScale(self.raw.as_ptr(), value) }
    }

    pub fn value_0x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value0_x(self.raw.as_ptr()) }
    }

    pub fn set_value_0x(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value0_x(self.raw.as_ptr(), value) }
    }

    pub fn value_0y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value0_y(self.raw.as_ptr()) }
    }

    pub fn set_value_0y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value0_y(self.raw.as_ptr(), value) }
    }

    pub fn value_0z(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value0_z(self.raw.as_ptr()) }
    }

    pub fn set_value_0z(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value0_z(self.raw.as_ptr(), value) }
    }

    pub fn value_1w(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value1_w(self.raw.as_ptr()) }
    }

    pub fn set_value_1w(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value1_w(self.raw.as_ptr(), value) }
    }

    pub fn value_0w(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value0_w(self.raw.as_ptr()) }
    }

    pub fn set_value_0w(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value0_w(self.raw.as_ptr(), value) }
    }

    pub fn value_1x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value1_x(self.raw.as_ptr()) }
    }

    pub fn set_value_1x(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value1_x(self.raw.as_ptr(), value) }
    }

    pub fn value_1y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value1_y(self.raw.as_ptr()) }
    }

    pub fn set_value_1y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value1_y(self.raw.as_ptr(), value) }
    }

    pub fn value_2w(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value2_w(self.raw.as_ptr()) }
    }

    pub fn set_value_2w(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value2_w(self.raw.as_ptr(), value) }
    }

    pub fn value_3y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value3_y(self.raw.as_ptr()) }
    }

    pub fn set_value_3y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value3_y(self.raw.as_ptr(), value) }
    }

    pub fn value_3x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value3_x(self.raw.as_ptr()) }
    }

    pub fn set_value_3x(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value3_x(self.raw.as_ptr(), value) }
    }

    pub fn base_color(&self) -> crate::math::Vector4f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2WaterfallData_get_baseColor(self.raw.as_ptr())
                as *const crate::math::Vector4f)
        }
    }

    pub fn set_base_color(&mut self, value: crate::math::Vector4f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2WaterfallData_set_baseColor(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector4f as *const _,
            )
        }
    }

    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn unknown_0(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_unknown0(self.raw.as_ptr()) }
    }

    pub fn set_unknown_0(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_unknown0(self.raw.as_ptr(), value) }
    }

    pub fn value_3w(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value3_w(self.raw.as_ptr()) }
    }

    pub fn set_value_3w(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value3_w(self.raw.as_ptr(), value) }
    }

    pub fn value_3z(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value3_z(self.raw.as_ptr()) }
    }

    pub fn set_value_3z(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value3_z(self.raw.as_ptr(), value) }
    }

    pub fn value_4y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_value4_y(self.raw.as_ptr()) }
    }

    pub fn set_value_4y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_value4_y(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_unknown1(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_unknown1(self.raw.as_ptr(), value) }
    }

    pub fn unknown_2(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_unknown2(self.raw.as_ptr()) }
    }

    pub fn set_unknown_2(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_unknown2(self.raw.as_ptr(), value) }
    }

    pub fn unknown_3(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_unknown3(self.raw.as_ptr()) }
    }

    pub fn set_unknown_3(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_unknown3(self.raw.as_ptr(), value) }
    }

    pub fn unknown_4(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_get_unknown4(self.raw.as_ptr()) }
    }

    pub fn set_unknown_4(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WaterfallData_set_unknown4(self.raw.as_ptr(), value) }
    }
}

impl Default for WaterfallData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ParticleGeosetData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ParticleGeosetData>,
}

impl Drop for ParticleGeosetData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ParticleGeosetData_delete(self.raw.as_ptr()) }
    }
}

impl ParticleGeosetData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ParticleGeosetData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleGeosetData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ParticleGeosetData {}

impl core::fmt::Debug for ParticleGeosetData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ParticleGeosetData").finish_non_exhaustive()
    }
}

impl ParticleGeosetData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ParticleGeosetData_new();
            Self::from_raw(raw).expect("native ParticleGeosetData allocation failed")
        }
    }

    pub fn geoset(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleGeosetData_get_geoset(self.raw.as_ptr()) }
    }

    pub fn set_geoset(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleGeosetData_set_geoset(self.raw.as_ptr(), value) }
    }
}

impl Default for ParticleGeosetData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct EdgeFadeData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2EdgeFadeData>,
}

impl Drop for EdgeFadeData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_delete(self.raw.as_ptr()) }
    }
}

impl EdgeFadeData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2EdgeFadeData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| EdgeFadeData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for EdgeFadeData {}

impl core::fmt::Debug for EdgeFadeData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("EdgeFadeData").finish_non_exhaustive()
    }
}

impl EdgeFadeData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2EdgeFadeData_new();
            Self::from_raw(raw).expect("native EdgeFadeData allocation failed")
        }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn value_0_len() -> usize {
        2
    }

    /// # Panics
    /// If `index >= 2`, matching Rust slice indexing.
    pub fn value_0(&self, index: usize) -> f32 {
        assert!(index < 2, "value_0 index {index} out of range (len 2)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_get_value0_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 2`.
    pub fn set_value_0(&mut self, index: usize, value: f32) {
        assert!(index < 2, "value_0 index {index} out of range (len 2)");
        // SAFETY: index checked above.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_set_value0_at(self.raw.as_ptr(), index, value) }
    }

    pub fn value_8(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_get_value8(self.raw.as_ptr()) }
    }

    pub fn set_value_8(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_set_value8(self.raw.as_ptr(), value) }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn value_c_len() -> usize {
        12
    }

    /// # Panics
    /// If `index >= 12`, matching Rust slice indexing.
    pub fn value_c(&self, index: usize) -> u8 {
        assert!(index < 12, "value_c index {index} out of range (len 12)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_get_valueC_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 12`.
    pub fn set_value_c(&mut self, index: usize, value: u8) {
        assert!(index < 12, "value_c index {index} out of range (len 12)");
        // SAFETY: index checked above.
        unsafe { ffi::whiteout_m2_M2EdgeFadeData_set_valueC_at(self.raw.as_ptr(), index, value) }
    }
}

impl Default for EdgeFadeData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct DistanceFadeData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2DistanceFadeData>,
}

impl Drop for DistanceFadeData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_delete(self.raw.as_ptr()) }
    }
}

impl DistanceFadeData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2DistanceFadeData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DistanceFadeData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for DistanceFadeData {}

impl core::fmt::Debug for DistanceFadeData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DistanceFadeData").finish_non_exhaustive()
    }
}

impl DistanceFadeData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2DistanceFadeData_new();
            Self::from_raw(raw).expect("native DistanceFadeData allocation failed")
        }
    }

    pub fn squared_far_dist(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_get_squaredFarDist(self.raw.as_ptr()) }
    }

    pub fn set_squared_far_dist(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_set_squaredFarDist(self.raw.as_ptr(), value) }
    }

    pub fn squared_near_dist(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_get_squaredNearDist(self.raw.as_ptr()) }
    }

    pub fn set_squared_near_dist(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_set_squaredNearDist(self.raw.as_ptr(), value) }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn reserved_len() -> usize {
        2
    }

    /// # Panics
    /// If `index >= 2`, matching Rust slice indexing.
    pub fn reserved(&self, index: usize) -> u32 {
        assert!(index < 2, "reserved index {index} out of range (len 2)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2DistanceFadeData_get_reserved_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 2`.
    pub fn set_reserved(&mut self, index: usize, value: u32) {
        assert!(index < 2, "reserved index {index} out of range (len 2)");
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2DistanceFadeData_set_reserved_at(self.raw.as_ptr(), index, value)
        }
    }
}

impl Default for DistanceFadeData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct DetailedLightData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2DetailedLightData>,
}

impl Drop for DetailedLightData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_delete(self.raw.as_ptr()) }
    }
}

impl DetailedLightData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2DetailedLightData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DetailedLightData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for DetailedLightData {}

impl core::fmt::Debug for DetailedLightData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DetailedLightData").finish_non_exhaustive()
    }
}

impl DetailedLightData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2DetailedLightData_new();
            Self::from_raw(raw).expect("native DetailedLightData allocation failed")
        }
    }

    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn unknown_0(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_get_unknown0(self.raw.as_ptr()) }
    }

    pub fn set_unknown_0(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_set_unknown0(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_get_unknown1(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DetailedLightData_set_unknown1(self.raw.as_ptr(), value) }
    }
}

impl Default for DetailedLightData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct DebugOcclusionData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2DebugOcclusionData>,
}

impl Drop for DebugOcclusionData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_delete(self.raw.as_ptr()) }
    }
}

impl DebugOcclusionData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2DebugOcclusionData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DebugOcclusionData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for DebugOcclusionData {}

impl core::fmt::Debug for DebugOcclusionData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DebugOcclusionData").finish_non_exhaustive()
    }
}

impl DebugOcclusionData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2DebugOcclusionData_new();
            Self::from_raw(raw).expect("native DebugOcclusionData allocation failed")
        }
    }

    pub fn unknown_1_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_get_unknown1_1(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_set_unknown1_1(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1_2(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_get_unknown1_2(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1_2(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_set_unknown1_2(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1_3(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_get_unknown1_3(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1_3(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_set_unknown1_3(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1_4(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_get_unknown1_4(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1_4(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DebugOcclusionData_set_unknown1_4(self.raw.as_ptr(), value) }
    }
}

impl Default for DebugOcclusionData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct TexturedLightData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2TexturedLightData>,
}

impl Drop for TexturedLightData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_delete(self.raw.as_ptr()) }
    }
}

impl TexturedLightData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2TexturedLightData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TexturedLightData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for TexturedLightData {}

impl core::fmt::Debug for TexturedLightData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TexturedLightData").finish_non_exhaustive()
    }
}

impl TexturedLightData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2TexturedLightData_new();
            Self::from_raw(raw).expect("native TexturedLightData allocation failed")
        }
    }

    pub fn unknown_0(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_get_unknown0(self.raw.as_ptr()) }
    }

    pub fn set_unknown_0(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_set_unknown0(self.raw.as_ptr(), value) }
    }

    pub fn unknown_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_get_unknown1(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_set_unknown1(self.raw.as_ptr(), value) }
    }

    pub fn texture_lookup(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_get_textureLookup(self.raw.as_ptr()) }
    }

    pub fn set_texture_lookup(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_set_textureLookup(self.raw.as_ptr(), value) }
    }

    pub fn unknown_2(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_get_unknown2(self.raw.as_ptr()) }
    }

    pub fn set_unknown_2(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2TexturedLightData_set_unknown2(self.raw.as_ptr(), value) }
    }
}

impl Default for TexturedLightData {
    fn default() -> Self {
        Self::new()
    }
}

/// One DPIV (pivot displacement) record, 32 bytes.
///
/// The client keeps the payload pointer and a record count of `chunkSize / 32`, so a chunk holds N of these — the corpus has both 1- and 2-record chunks.
pub struct PivotDisplacementData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PivotDisplacementData>,
}

impl Drop for PivotDisplacementData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PivotDisplacementData_delete(self.raw.as_ptr()) }
    }
}

impl PivotDisplacementData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PivotDisplacementData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PivotDisplacementData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PivotDisplacementData {}

impl core::fmt::Debug for PivotDisplacementData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PivotDisplacementData")
            .finish_non_exhaustive()
    }
}

impl PivotDisplacementData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PivotDisplacementData_new();
            Self::from_raw(raw).expect("native PivotDisplacementData allocation failed")
        }
    }

    /// small displacement; Z varies most
    pub fn offset(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PivotDisplacementData_get_offset(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_offset(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PivotDisplacementData_set_offset(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// 0 or 1
    pub fn flags(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PivotDisplacementData_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PivotDisplacementData_set_flags(self.raw.as_ptr(), value) }
    }

    /// always 0
    /// Number of elements — a fixed-size C++ array.
    pub const fn reserved_len() -> usize {
        4
    }

    /// # Panics
    /// If `index >= 4`, matching Rust slice indexing.
    pub fn reserved(&self, index: usize) -> u32 {
        assert!(index < 4, "reserved index {index} out of range (len 4)");
        // SAFETY: index checked above; plain scalar read.
        unsafe {
            ffi::whiteout_m2_M2PivotDisplacementData_get_reserved_at(self.raw.as_ptr(), index)
        }
    }

    /// # Panics
    /// If `index >= 4`.
    pub fn set_reserved(&mut self, index: usize, value: u32) {
        assert!(index < 4, "reserved index {index} out of range (len 4)");
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2PivotDisplacementData_set_reserved_at(
                self.raw.as_ptr(),
                index,
                value,
            )
        }
    }
}

impl Default for PivotDisplacementData {
    fn default() -> Self {
        Self::new()
    }
}

pub struct PhysicsCollision {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsCollision>,
}

impl Drop for PhysicsCollision {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsCollision_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsCollision {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsCollision) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsCollision { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsCollision {}

impl core::fmt::Debug for PhysicsCollision {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsCollision").finish_non_exhaustive()
    }
}

impl PhysicsCollision {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsCollision_new();
            Self::from_raw(raw).expect("native PhysicsCollision allocation failed")
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn vertex_positions(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m2_M2PhysicsCollision_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_vertexPositions_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn vertex_positions_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m2_M2PhysicsCollision_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_vertexPositions_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_vertex_positions(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PhysicsCollision_assign_vertexPositions(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vertex_positions(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2PhysicsCollision_resize_vertexPositions(self.raw.as_ptr(), count)
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn face_normals(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_faceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_faceNormals_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn face_normals_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_faceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_faceNormals_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_face_normals(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PhysicsCollision_assign_faceNormals(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_face_normals(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsCollision_resize_faceNormals(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn indices(&self) -> &[i16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_indices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_indices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn indices_mut(&mut self) -> &mut [i16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_indices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2PhysicsCollision_get_indices_data(self.raw.as_ptr()) as *mut i16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_indices(&mut self, values: &[i16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PhysicsCollision_assign_indices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsCollision_resize_indices(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn flags(&self) -> &[i16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_flags_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsCollision_get_flags_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn flags_mut(&mut self) -> &mut [i16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsCollision_get_flags_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2PhysicsCollision_get_flags_data(self.raw.as_ptr()) as *mut i16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_flags(&mut self, values: &[i16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PhysicsCollision_assign_flags(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_flags(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsCollision_resize_flags(self.raw.as_ptr(), count) }
    }
}

impl Default for PhysicsCollision {
    fn default() -> Self {
        Self::new()
    }
}

pub struct SkinSection {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2SkinSection>,
}

impl Drop for SkinSection {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2SkinSection_delete(self.raw.as_ptr()) }
    }
}

impl SkinSection {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2SkinSection) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SkinSection { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for SkinSection {}

impl core::fmt::Debug for SkinSection {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SkinSection").finish_non_exhaustive()
    }
}

impl SkinSection {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2SkinSection_new();
            Self::from_raw(raw).expect("native SkinSection allocation failed")
        }
    }

    pub fn skin_section_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_skinSectionId(self.raw.as_ptr()) }
    }

    pub fn set_skin_section_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_skinSectionId(self.raw.as_ptr(), value) }
    }

    pub fn level(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_level(self.raw.as_ptr()) }
    }

    pub fn set_level(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_level(self.raw.as_ptr(), value) }
    }

    pub fn vertex_start(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_vertexStart(self.raw.as_ptr()) }
    }

    pub fn set_vertex_start(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_vertexStart(self.raw.as_ptr(), value) }
    }

    pub fn vertex_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_vertexCount(self.raw.as_ptr()) }
    }

    pub fn set_vertex_count(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_vertexCount(self.raw.as_ptr(), value) }
    }

    pub fn index_start(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_indexStart(self.raw.as_ptr()) }
    }

    pub fn set_index_start(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_indexStart(self.raw.as_ptr(), value) }
    }

    pub fn index_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_indexCount(self.raw.as_ptr()) }
    }

    pub fn set_index_count(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_indexCount(self.raw.as_ptr(), value) }
    }

    pub fn bone_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_boneCount(self.raw.as_ptr()) }
    }

    pub fn set_bone_count(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_boneCount(self.raw.as_ptr(), value) }
    }

    pub fn bone_combo_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_boneComboIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_combo_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_boneComboIndex(self.raw.as_ptr(), value) }
    }

    pub fn bone_influences(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_boneInfluences(self.raw.as_ptr()) }
    }

    pub fn set_bone_influences(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_boneInfluences(self.raw.as_ptr(), value) }
    }

    pub fn center_bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_centerBoneIndex(self.raw.as_ptr()) }
    }

    pub fn set_center_bone_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_centerBoneIndex(self.raw.as_ptr(), value) }
    }

    pub fn center_position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2SkinSection_get_centerPosition(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_center_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2SkinSection_set_centerPosition(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn sort_center_position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2SkinSection_get_sortCenterPosition(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_sort_center_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2SkinSection_set_sortCenterPosition(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn sort_radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_get_sortRadius(self.raw.as_ptr()) }
    }

    pub fn set_sort_radius(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinSection_set_sortRadius(self.raw.as_ptr(), value) }
    }
}

impl Default for SkinSection {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Batch {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Batch>,
}

impl Drop for Batch {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Batch_delete(self.raw.as_ptr()) }
    }
}

impl Batch {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Batch) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Batch { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Batch {}

impl core::fmt::Debug for Batch {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Batch").finish_non_exhaustive()
    }
}

impl Batch {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Batch_new();
            Self::from_raw(raw).expect("native Batch allocation failed")
        }
    }

    pub fn flags(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn priority_plane(&self) -> i8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_priorityPlane(self.raw.as_ptr()) }
    }

    pub fn set_priority_plane(&mut self, value: i8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_priorityPlane(self.raw.as_ptr(), value) }
    }

    pub fn shader_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_shaderId(self.raw.as_ptr()) }
    }

    pub fn set_shader_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_shaderId(self.raw.as_ptr(), value) }
    }

    pub fn skin_section_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_skinSectionIndex(self.raw.as_ptr()) }
    }

    pub fn set_skin_section_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_skinSectionIndex(self.raw.as_ptr(), value) }
    }

    pub fn geoset_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_geosetIndex(self.raw.as_ptr()) }
    }

    pub fn set_geoset_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_geosetIndex(self.raw.as_ptr(), value) }
    }

    pub fn color_index(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_colorIndex(self.raw.as_ptr()) }
    }

    pub fn set_color_index(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_colorIndex(self.raw.as_ptr(), value) }
    }

    pub fn material_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_materialIndex(self.raw.as_ptr()) }
    }

    pub fn set_material_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_materialIndex(self.raw.as_ptr(), value) }
    }

    pub fn material_layer(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_materialLayer(self.raw.as_ptr()) }
    }

    pub fn set_material_layer(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_materialLayer(self.raw.as_ptr(), value) }
    }

    pub fn texture_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_textureCount(self.raw.as_ptr()) }
    }

    pub fn set_texture_count(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_textureCount(self.raw.as_ptr(), value) }
    }

    pub fn texture_combo_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_textureComboIndex(self.raw.as_ptr()) }
    }

    pub fn set_texture_combo_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_textureComboIndex(self.raw.as_ptr(), value) }
    }

    pub fn texture_coord_combo_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_textureCoordComboIndex(self.raw.as_ptr()) }
    }

    pub fn set_texture_coord_combo_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_textureCoordComboIndex(self.raw.as_ptr(), value) }
    }

    pub fn texture_weight_combo_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_textureWeightComboIndex(self.raw.as_ptr()) }
    }

    pub fn set_texture_weight_combo_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_textureWeightComboIndex(self.raw.as_ptr(), value) }
    }

    pub fn texture_transform_combo_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_get_textureTransformComboIndex(self.raw.as_ptr()) }
    }

    pub fn set_texture_transform_combo_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Batch_set_textureTransformComboIndex(self.raw.as_ptr(), value) }
    }
}

impl Default for Batch {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ShadowBatch {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ShadowBatch>,
}

impl Drop for ShadowBatch {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_delete(self.raw.as_ptr()) }
    }
}

impl ShadowBatch {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ShadowBatch) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ShadowBatch { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ShadowBatch {}

impl core::fmt::Debug for ShadowBatch {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ShadowBatch").finish_non_exhaustive()
    }
}

impl ShadowBatch {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ShadowBatch_new();
            Self::from_raw(raw).expect("native ShadowBatch allocation failed")
        }
    }

    pub fn flags(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn flags_2(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_flags2(self.raw.as_ptr()) }
    }

    pub fn set_flags_2(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_flags2(self.raw.as_ptr(), value) }
    }

    pub fn unknown_0(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_unknown0(self.raw.as_ptr()) }
    }

    pub fn set_unknown_0(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_unknown0(self.raw.as_ptr(), value) }
    }

    pub fn submesh_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_submeshId(self.raw.as_ptr()) }
    }

    pub fn set_submesh_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_submeshId(self.raw.as_ptr(), value) }
    }

    pub fn texture_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_textureId(self.raw.as_ptr()) }
    }

    pub fn set_texture_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_textureId(self.raw.as_ptr(), value) }
    }

    pub fn color_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_colorId(self.raw.as_ptr()) }
    }

    pub fn set_color_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_colorId(self.raw.as_ptr(), value) }
    }

    pub fn transparency_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_get_transparencyId(self.raw.as_ptr()) }
    }

    pub fn set_transparency_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShadowBatch_set_transparencyId(self.raw.as_ptr(), value) }
    }
}

impl Default for ShadowBatch {
    fn default() -> Self {
        Self::new()
    }
}

pub struct SkinProfile {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2SkinProfile>,
}

impl Drop for SkinProfile {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2SkinProfile_delete(self.raw.as_ptr()) }
    }
}

impl SkinProfile {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2SkinProfile) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SkinProfile { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for SkinProfile {}

impl core::fmt::Debug for SkinProfile {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SkinProfile").finish_non_exhaustive()
    }
}

impl SkinProfile {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2SkinProfile_new();
            Self::from_raw(raw).expect("native SkinProfile allocation failed")
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn vertices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2SkinProfile_get_vertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2SkinProfile_get_vertices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn vertices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2SkinProfile_get_vertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2SkinProfile_get_vertices_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_vertices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2SkinProfile_assign_vertices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vertices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SkinProfile_resize_vertices(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2SkinProfile_get_indices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2SkinProfile_get_indices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2SkinProfile_get_indices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2SkinProfile_get_indices_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2SkinProfile_assign_indices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SkinProfile_resize_indices(self.raw.as_ptr(), count) }
    }

    pub fn submeshes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinProfile_get_submeshes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn submeshes(&self, index: usize) -> Option<crate::support::Ref<'_, SkinSection>> {
        if index >= self.submeshes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SkinSection {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_submeshes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn submeshes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SkinSection>> {
        if index >= self.submeshes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SkinSection {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_submeshes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn submeshes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SkinSection>> {
        (0..self.submeshes_len()).map(move |i| self.submeshes(i).expect("index below len"))
    }

    pub fn resize_submeshes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SkinProfile_resize_submeshes(self.raw.as_ptr(), count) }
    }

    pub fn batches_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinProfile_get_batches_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn batches(&self, index: usize) -> Option<crate::support::Ref<'_, Batch>> {
        if index >= self.batches_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Batch {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_batches_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn batches_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Batch>> {
        if index >= self.batches_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Batch {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_batches_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn batches_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Batch>> {
        (0..self.batches_len()).map(move |i| self.batches(i).expect("index below len"))
    }

    pub fn resize_batches(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SkinProfile_resize_batches(self.raw.as_ptr(), count) }
    }

    pub fn lod_vertex_base(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinProfile_get_lodVertexBase(self.raw.as_ptr()) }
    }

    pub fn set_lod_vertex_base(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinProfile_set_lodVertexBase(self.raw.as_ptr(), value) }
    }

    pub fn shadow_batches_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SkinProfile_get_shadowBatches_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn shadow_batches(&self, index: usize) -> Option<crate::support::Ref<'_, ShadowBatch>> {
        if index >= self.shadow_batches_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ShadowBatch {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_shadowBatches_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn shadow_batches_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ShadowBatch>> {
        if index >= self.shadow_batches_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ShadowBatch {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2SkinProfile_get_shadowBatches_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn shadow_batches_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ShadowBatch>> {
        (0..self.shadow_batches_len())
            .map(move |i| self.shadow_batches(i).expect("index below len"))
    }

    pub fn resize_shadow_batches(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SkinProfile_resize_shadowBatches(self.raw.as_ptr(), count) }
    }
}

impl Default for SkinProfile {
    fn default() -> Self {
        Self::new()
    }
}

pub struct GlobalFlags {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2GlobalFlags>,
}

impl Drop for GlobalFlags {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2GlobalFlags_delete(self.raw.as_ptr()) }
    }
}

impl GlobalFlags {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2GlobalFlags) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| GlobalFlags { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for GlobalFlags {}

impl core::fmt::Debug for GlobalFlags {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("GlobalFlags").finish_non_exhaustive()
    }
}

impl GlobalFlags {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2GlobalFlags_new();
            Self::from_raw(raw).expect("native GlobalFlags allocation failed")
        }
    }

    pub fn value(&self) -> GlobalFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        GlobalFlag(unsafe { ffi::whiteout_m2_M2GlobalFlags_get_value(self.raw.as_ptr()) })
    }

    pub fn set_value(&mut self, value: GlobalFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2GlobalFlags_set_value(self.raw.as_ptr(), value.0) }
    }
}

impl Default for GlobalFlags {
    fn default() -> Self {
        Self::new()
    }
}

pub struct GlobalSequence {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2GlobalSequence>,
}

impl Drop for GlobalSequence {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2GlobalSequence_delete(self.raw.as_ptr()) }
    }
}

impl GlobalSequence {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2GlobalSequence) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| GlobalSequence { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for GlobalSequence {}

impl core::fmt::Debug for GlobalSequence {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("GlobalSequence").finish_non_exhaustive()
    }
}

impl GlobalSequence {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2GlobalSequence_new();
            Self::from_raw(raw).expect("native GlobalSequence allocation failed")
        }
    }

    pub fn timestamp(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2GlobalSequence_get_timestamp(self.raw.as_ptr()) }
    }

    pub fn set_timestamp(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2GlobalSequence_set_timestamp(self.raw.as_ptr(), value) }
    }
}

impl Default for GlobalSequence {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Sequence {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Sequence>,
}

impl Drop for Sequence {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Sequence_delete(self.raw.as_ptr()) }
    }
}

impl Sequence {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Sequence) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Sequence { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Sequence {}

impl core::fmt::Debug for Sequence {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Sequence").finish_non_exhaustive()
    }
}

impl Sequence {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Sequence_new();
            Self::from_raw(raw).expect("native Sequence allocation failed")
        }
    }

    pub fn id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_id(self.raw.as_ptr()) }
    }

    pub fn set_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_id(self.raw.as_ptr(), value) }
    }

    pub fn variation_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_variationIndex(self.raw.as_ptr()) }
    }

    pub fn set_variation_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_variationIndex(self.raw.as_ptr(), value) }
    }

    pub fn duration(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_duration(self.raw.as_ptr()) }
    }

    pub fn set_duration(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_duration(self.raw.as_ptr(), value) }
    }

    pub fn movespeed(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_movespeed(self.raw.as_ptr()) }
    }

    pub fn set_movespeed(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_movespeed(self.raw.as_ptr(), value) }
    }

    pub fn flags(&self) -> SequenceFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        SequenceFlag(unsafe { ffi::whiteout_m2_M2Sequence_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: SequenceFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_flags(self.raw.as_ptr(), value.0) }
    }

    pub fn frequency(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_frequency(self.raw.as_ptr()) }
    }

    pub fn set_frequency(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_frequency(self.raw.as_ptr(), value) }
    }

    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_padding(self.raw.as_ptr()) }
    }

    pub fn set_padding(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_padding(self.raw.as_ptr(), value) }
    }

    pub fn replay_min(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_replayMin(self.raw.as_ptr()) }
    }

    pub fn set_replay_min(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_replayMin(self.raw.as_ptr(), value) }
    }

    pub fn replay_max(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_replayMax(self.raw.as_ptr()) }
    }

    pub fn set_replay_max(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_replayMax(self.raw.as_ptr(), value) }
    }

    pub fn blend_time_in(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_blendTimeIn(self.raw.as_ptr()) }
    }

    pub fn set_blend_time_in(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_blendTimeIn(self.raw.as_ptr(), value) }
    }

    pub fn blend_time_out(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_blendTimeOut(self.raw.as_ptr()) }
    }

    pub fn set_blend_time_out(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_blendTimeOut(self.raw.as_ptr(), value) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn bounding(&self) -> crate::support::Ref<'_, Extent> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Sequence_get_bounding(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bounding_mut(&mut self) -> crate::support::RefMut<'_, Extent> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Sequence_get_bounding(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn variation_next(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_variationNext(self.raw.as_ptr()) }
    }

    pub fn set_variation_next(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_variationNext(self.raw.as_ptr(), value) }
    }

    pub fn alias_next(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_get_aliasNext(self.raw.as_ptr()) }
    }

    pub fn set_alias_next(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Sequence_set_aliasNext(self.raw.as_ptr(), value) }
    }
}

impl Default for Sequence {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Vertex {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Vertex>,
}

impl Drop for Vertex {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Vertex_delete(self.raw.as_ptr()) }
    }
}

impl Vertex {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Vertex) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Vertex { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Vertex {}

impl core::fmt::Debug for Vertex {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Vertex").finish_non_exhaustive()
    }
}

impl Vertex {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Vertex_new();
            Self::from_raw(raw).expect("native Vertex allocation failed")
        }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Vertex_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Vertex_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn bone_weights_len() -> usize {
        4
    }

    /// # Panics
    /// If `index >= 4`, matching Rust slice indexing.
    pub fn bone_weights(&self, index: usize) -> u8 {
        assert!(index < 4, "bone_weights index {index} out of range (len 4)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2Vertex_get_boneWeights_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 4`.
    pub fn set_bone_weights(&mut self, index: usize, value: u8) {
        assert!(index < 4, "bone_weights index {index} out of range (len 4)");
        // SAFETY: index checked above.
        unsafe { ffi::whiteout_m2_M2Vertex_set_boneWeights_at(self.raw.as_ptr(), index, value) }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn bone_indices_len() -> usize {
        4
    }

    /// # Panics
    /// If `index >= 4`, matching Rust slice indexing.
    pub fn bone_indices(&self, index: usize) -> u8 {
        assert!(index < 4, "bone_indices index {index} out of range (len 4)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2Vertex_get_boneIndices_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 4`.
    pub fn set_bone_indices(&mut self, index: usize, value: u8) {
        assert!(index < 4, "bone_indices index {index} out of range (len 4)");
        // SAFETY: index checked above.
        unsafe { ffi::whiteout_m2_M2Vertex_set_boneIndices_at(self.raw.as_ptr(), index, value) }
    }

    pub fn normal(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Vertex_get_normal(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_normal(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Vertex_set_normal(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn tex_coords_len() -> usize {
        2
    }

    /// # Panics
    /// If `index >= 2`, matching Rust slice indexing. The
    /// native accessor does no bounds checking of its own, so
    /// this check is what keeps the method safe to call.
    pub fn tex_coords(&self, index: usize) -> crate::math::Vector2f {
        assert!(index < 2, "tex_coords index {index} out of range (len 2)");
        // SAFETY: index checked above; the getter returns an
        // interior pointer to a layout-identical POD, copied
        // out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Vertex_get_texCoords_at(self.raw.as_ptr(), index)
                as *const crate::math::Vector2f)
        }
    }
}

impl Default for Vertex {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Bone {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Bone>,
}

impl Drop for Bone {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Bone_delete(self.raw.as_ptr()) }
    }
}

impl Bone {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Bone) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Bone { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Bone {}

impl core::fmt::Debug for Bone {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Bone").finish_non_exhaustive()
    }
}

impl Bone {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Bone_new();
            Self::from_raw(raw).expect("native Bone allocation failed")
        }
    }

    pub fn key_bone_id(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_get_keyBoneId(self.raw.as_ptr()) }
    }

    pub fn set_key_bone_id(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_set_keyBoneId(self.raw.as_ptr(), value) }
    }

    pub fn flags(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn parent_bone_id(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_get_parentBoneId(self.raw.as_ptr()) }
    }

    pub fn set_parent_bone_id(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_set_parentBoneId(self.raw.as_ptr(), value) }
    }

    pub fn submesh_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_get_submeshId(self.raw.as_ptr()) }
    }

    pub fn set_submesh_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_set_submeshId(self.raw.as_ptr(), value) }
    }

    pub fn bone_name_crc(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_get_boneNameCRC(self.raw.as_ptr()) }
    }

    pub fn set_bone_name_crc(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Bone_set_boneNameCRC(self.raw.as_ptr(), value) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn translation(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_translation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn translation_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_translation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn rotation(&self) -> crate::support::Ref<'_, AnimationTrackM2CompatQuaternion> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackM2CompatQuaternion {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_rotation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn rotation_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackM2CompatQuaternion> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackM2CompatQuaternion {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_rotation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn scale(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_scale(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn scale_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Bone_get_scale(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn pivot(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Bone_get_pivot(self.raw.as_ptr()) as *const crate::math::Vector3f)
        }
    }

    pub fn set_pivot(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Bone_set_pivot(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for Bone {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Texture {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Texture>,
}

impl Drop for Texture {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Texture_delete(self.raw.as_ptr()) }
    }
}

impl Texture {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Texture) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Texture { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Texture {}

impl core::fmt::Debug for Texture {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Texture").finish_non_exhaustive()
    }
}

impl Texture {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Texture_new();
            Self::from_raw(raw).expect("native Texture allocation failed")
        }
    }

    pub fn type_(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Texture_get_type(self.raw.as_ptr()) }
    }

    pub fn set_type_(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Texture_set_type(self.raw.as_ptr(), value) }
    }

    pub fn flags(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Texture_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Texture_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn filename(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m2_M2Texture_get_filename(self.raw.as_ptr()))
        }
    }

    pub fn set_filename(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m2_M2Texture_set_filename(self.raw.as_ptr(), value.as_ptr()) }
    }
}

impl Default for Texture {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Material {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Material>,
}

impl Drop for Material {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Material_delete(self.raw.as_ptr()) }
    }
}

impl Material {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Material) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Material { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Material {}

impl core::fmt::Debug for Material {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Material").finish_non_exhaustive()
    }
}

impl Material {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Material_new();
            Self::from_raw(raw).expect("native Material allocation failed")
        }
    }

    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Material_get_flags(self.raw.as_ptr()) }
    }

    pub fn set_flags(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Material_set_flags(self.raw.as_ptr(), value) }
    }

    pub fn blending_mode(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Material_get_blendingMode(self.raw.as_ptr()) }
    }

    pub fn set_blending_mode(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Material_set_blendingMode(self.raw.as_ptr(), value) }
    }
}

impl Default for Material {
    fn default() -> Self {
        Self::new()
    }
}

pub struct TextureWeight {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2TextureWeight>,
}

impl Drop for TextureWeight {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2TextureWeight_delete(self.raw.as_ptr()) }
    }
}

impl TextureWeight {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2TextureWeight) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TextureWeight { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for TextureWeight {}

impl core::fmt::Debug for TextureWeight {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TextureWeight").finish_non_exhaustive()
    }
}

impl TextureWeight {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2TextureWeight_new();
            Self::from_raw(raw).expect("native TextureWeight allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn weight(&self) -> crate::support::Ref<'_, AnimationTrackI16> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureWeight_get_weight(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn weight_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackI16> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureWeight_get_weight(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for TextureWeight {
    fn default() -> Self {
        Self::new()
    }
}

pub struct TextureTransform {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2TextureTransform>,
}

impl Drop for TextureTransform {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2TextureTransform_delete(self.raw.as_ptr()) }
    }
}

impl TextureTransform {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2TextureTransform) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TextureTransform { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for TextureTransform {}

impl core::fmt::Debug for TextureTransform {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TextureTransform").finish_non_exhaustive()
    }
}

impl TextureTransform {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2TextureTransform_new();
            Self::from_raw(raw).expect("native TextureTransform allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn translation(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_translation(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn translation_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_translation(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn rotation(&self) -> crate::support::Ref<'_, AnimationTrackQuaternion> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackQuaternion {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_rotation(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn rotation_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackQuaternion> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackQuaternion {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_rotation(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn scaling(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_scaling(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn scaling_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2TextureTransform_get_scaling(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for TextureTransform {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ColorAnimation {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ColorAnimation>,
}

impl Drop for ColorAnimation {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ColorAnimation_delete(self.raw.as_ptr()) }
    }
}

impl ColorAnimation {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ColorAnimation) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ColorAnimation { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ColorAnimation {}

impl core::fmt::Debug for ColorAnimation {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ColorAnimation").finish_non_exhaustive()
    }
}

impl ColorAnimation {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ColorAnimation_new();
            Self::from_raw(raw).expect("native ColorAnimation allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn color(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ColorAnimation_get_color(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn color_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ColorAnimation_get_color(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn alpha(&self) -> crate::support::Ref<'_, AnimationTrackI16> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ColorAnimation_get_alpha(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn alpha_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackI16> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ColorAnimation_get_alpha(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for ColorAnimation {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Light {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Light>,
}

impl Drop for Light {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Light_delete(self.raw.as_ptr()) }
    }
}

impl Light {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Light) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Light { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Light {}

impl core::fmt::Debug for Light {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Light").finish_non_exhaustive()
    }
}

impl Light {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Light_new();
            Self::from_raw(raw).expect("native Light allocation failed")
        }
    }

    pub fn type_(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Light_get_type(self.raw.as_ptr()) }
    }

    pub fn set_type_(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Light_set_type(self.raw.as_ptr(), value) }
    }

    pub fn bone_id(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Light_get_boneId(self.raw.as_ptr()) }
    }

    pub fn set_bone_id(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Light_set_boneId(self.raw.as_ptr(), value) }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Light_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Light_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn ambient_color(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_ambientColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn ambient_color_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_ambientColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn ambient_intensity(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_ambientIntensity(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn ambient_intensity_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_ambientIntensity(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn diffuse_color(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_diffuseColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn diffuse_color_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_diffuseColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn diffuse_intensity(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_diffuseIntensity(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn diffuse_intensity_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_diffuseIntensity(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn attenuation_start(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_attenuationStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn attenuation_start_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_attenuationStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn attenuation_end(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_attenuationEnd(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn attenuation_end_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Light_get_attenuationEnd(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn visibility(&self) -> crate::support::Ref<'_, AnimationTrackU8> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_visibility(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn visibility_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackU8> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Light_get_visibility(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Light {
    fn default() -> Self {
        Self::new()
    }
}

pub struct CameraSpline {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2CameraSpline>,
}

impl Drop for CameraSpline {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2CameraSpline_delete(self.raw.as_ptr()) }
    }
}

impl CameraSpline {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2CameraSpline) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CameraSpline { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for CameraSpline {}

impl core::fmt::Debug for CameraSpline {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("CameraSpline").finish_non_exhaustive()
    }
}

impl CameraSpline {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2CameraSpline_new();
            Self::from_raw(raw).expect("native CameraSpline allocation failed")
        }
    }

    pub fn value(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2CameraSpline_get_value(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_value(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2CameraSpline_set_value(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn in_tangent(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2CameraSpline_get_inTangent(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_in_tangent(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2CameraSpline_set_inTangent(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn out_tangent(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2CameraSpline_get_outTangent(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_out_tangent(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2CameraSpline_set_outTangent(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for CameraSpline {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Camera {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Camera>,
}

impl Drop for Camera {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Camera_delete(self.raw.as_ptr()) }
    }
}

impl Camera {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Camera) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Camera { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Camera {}

impl core::fmt::Debug for Camera {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Camera").finish_non_exhaustive()
    }
}

impl Camera {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Camera_new();
            Self::from_raw(raw).expect("native Camera allocation failed")
        }
    }

    pub fn type_(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_get_type(self.raw.as_ptr()) }
    }

    pub fn set_type_(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_set_type(self.raw.as_ptr(), value) }
    }

    pub fn field_of_view(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_get_fieldOfView(self.raw.as_ptr()) }
    }

    pub fn set_field_of_view(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_set_fieldOfView(self.raw.as_ptr(), value) }
    }

    pub fn far_clip(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_get_farClip(self.raw.as_ptr()) }
    }

    pub fn set_far_clip(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_set_farClip(self.raw.as_ptr(), value) }
    }

    pub fn near_clip(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_get_nearClip(self.raw.as_ptr()) }
    }

    pub fn set_near_clip(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Camera_set_nearClip(self.raw.as_ptr(), value) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn positions(&self) -> crate::support::Ref<'_, AnimationTrackM2CameraSpline> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackM2CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Camera_get_positions(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn positions_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackM2CameraSpline> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackM2CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Camera_get_positions(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn position_base(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Camera_get_positionBase(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position_base(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Camera_set_positionBase(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn target_positions(&self) -> crate::support::Ref<'_, AnimationTrackM2CameraSpline> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackM2CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Camera_get_targetPositions(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn target_positions_mut(
        &mut self,
    ) -> crate::support::RefMut<'_, AnimationTrackM2CameraSpline> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackM2CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Camera_get_targetPositions(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn target_position_base(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Camera_get_targetPositionBase(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_target_position_base(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Camera_set_targetPositionBase(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn roll(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Camera_get_roll(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn roll_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Camera_get_roll(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn field_of_view_track(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Camera_get_fieldOfViewTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn field_of_view_track_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Camera_get_fieldOfViewTrack(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for Camera {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Attachment {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Attachment>,
}

impl Drop for Attachment {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Attachment_delete(self.raw.as_ptr()) }
    }
}

impl Attachment {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Attachment) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Attachment { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Attachment {}

impl core::fmt::Debug for Attachment {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Attachment").finish_non_exhaustive()
    }
}

impl Attachment {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Attachment_new();
            Self::from_raw(raw).expect("native Attachment allocation failed")
        }
    }

    pub fn id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_get_id(self.raw.as_ptr()) }
    }

    pub fn set_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_set_id(self.raw.as_ptr(), value) }
    }

    pub fn bone_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_get_boneId(self.raw.as_ptr()) }
    }

    pub fn set_bone_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_set_boneId(self.raw.as_ptr(), value) }
    }

    pub fn unknown(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Attachment_set_unknown(self.raw.as_ptr(), value) }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Attachment_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Attachment_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn animate(&self) -> crate::support::Ref<'_, AnimationTrackU8> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Attachment_get_animate(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn animate_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackU8> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Attachment_get_animate(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Attachment {
    fn default() -> Self {
        Self::new()
    }
}

pub struct RibbonEmitter {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2RibbonEmitter>,
}

impl Drop for RibbonEmitter {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_delete(self.raw.as_ptr()) }
    }
}

impl RibbonEmitter {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2RibbonEmitter) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| RibbonEmitter { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for RibbonEmitter {}

impl core::fmt::Debug for RibbonEmitter {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RibbonEmitter").finish_non_exhaustive()
    }
}

impl RibbonEmitter {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2RibbonEmitter_new();
            Self::from_raw(raw).expect("native RibbonEmitter allocation failed")
        }
    }

    pub fn ribbon_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_ribbonId(self.raw.as_ptr()) }
    }

    pub fn set_ribbon_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_ribbonId(self.raw.as_ptr(), value) }
    }

    pub fn bone_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_boneId(self.raw.as_ptr()) }
    }

    pub fn set_bone_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_boneId(self.raw.as_ptr(), value) }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2RibbonEmitter_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2RibbonEmitter_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2RibbonEmitter_get_textureIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2RibbonEmitter_get_textureIndices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2RibbonEmitter_get_textureIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2RibbonEmitter_get_textureIndices_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2RibbonEmitter_assign_textureIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_resize_textureIndices(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn material_indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2RibbonEmitter_get_materialIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2RibbonEmitter_get_materialIndices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn material_indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2RibbonEmitter_get_materialIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2RibbonEmitter_get_materialIndices_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_material_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2RibbonEmitter_assign_materialIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_material_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_resize_materialIndices(self.raw.as_ptr(), count) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn color_track(&self) -> crate::support::Ref<'_, AnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_colorTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn color_track_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_colorTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn alpha_track(&self) -> crate::support::Ref<'_, AnimationTrackI16> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_alphaTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn alpha_track_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackI16> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackI16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_alphaTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn height_above(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_heightAbove(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn height_above_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_heightAbove(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn height_below(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_heightBelow(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn height_below_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_heightBelow(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn edges_per_second(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_edgesPerSecond(self.raw.as_ptr()) }
    }

    pub fn set_edges_per_second(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_edgesPerSecond(self.raw.as_ptr(), value) }
    }

    pub fn edge_lifetime(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_edgeLifetime(self.raw.as_ptr()) }
    }

    pub fn set_edge_lifetime(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_edgeLifetime(self.raw.as_ptr(), value) }
    }

    pub fn gravity(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_gravity(self.raw.as_ptr()) }
    }

    pub fn set_gravity(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_gravity(self.raw.as_ptr(), value) }
    }

    pub fn texture_rows(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_textureRows(self.raw.as_ptr()) }
    }

    pub fn set_texture_rows(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_textureRows(self.raw.as_ptr(), value) }
    }

    pub fn texture_cols(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_textureCols(self.raw.as_ptr()) }
    }

    pub fn set_texture_cols(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_textureCols(self.raw.as_ptr(), value) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn tex_slot(&self) -> crate::support::Ref<'_, AnimationTrackU16> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackU16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_texSlot(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn tex_slot_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackU16> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackU16 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_texSlot(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn visibility(&self) -> crate::support::Ref<'_, AnimationTrackU8> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_visibility(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn visibility_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackU8> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RibbonEmitter_get_visibility(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn priority_plane(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_priorityPlane(self.raw.as_ptr()) }
    }

    pub fn set_priority_plane(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_priorityPlane(self.raw.as_ptr(), value) }
    }

    pub fn ribbon_color_index(&self) -> i8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_ribbonColorIndex(self.raw.as_ptr()) }
    }

    pub fn set_ribbon_color_index(&mut self, value: i8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_set_ribbonColorIndex(self.raw.as_ptr(), value) }
    }

    pub fn texture_transform_index(&self) -> i8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RibbonEmitter_get_textureTransformIndex(self.raw.as_ptr()) }
    }

    pub fn set_texture_transform_index(&mut self, value: i8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2RibbonEmitter_set_textureTransformIndex(self.raw.as_ptr(), value)
        }
    }
}

impl Default for RibbonEmitter {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Box {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Box>,
}

impl Drop for Box {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Box_delete(self.raw.as_ptr()) }
    }
}

impl Box {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Box) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Box { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Box {}

impl core::fmt::Debug for Box {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Box").finish_non_exhaustive()
    }
}

impl Box {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Box_new();
            Self::from_raw(raw).expect("native Box allocation failed")
        }
    }

    pub fn minimum(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Box_get_minimum(self.raw.as_ptr()) as *const crate::math::Vector3f)
        }
    }

    pub fn set_minimum(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Box_set_minimum(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn maximum(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Box_get_maximum(self.raw.as_ptr()) as *const crate::math::Vector3f)
        }
    }

    pub fn set_maximum(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Box_set_maximum(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for Box {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ParticleEmitter {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ParticleEmitter>,
}

impl Drop for ParticleEmitter {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_delete(self.raw.as_ptr()) }
    }
}

impl ParticleEmitter {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ParticleEmitter) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleEmitter { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ParticleEmitter {}

impl core::fmt::Debug for ParticleEmitter {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ParticleEmitter").finish_non_exhaustive()
    }
}

impl ParticleEmitter {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ParticleEmitter_new();
            Self::from_raw(raw).expect("native ParticleEmitter allocation failed")
        }
    }

    pub fn particle_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_particleId(self.raw.as_ptr()) }
    }

    pub fn set_particle_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_particleId(self.raw.as_ptr(), value) }
    }

    pub fn flags(&self) -> ParticleFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        ParticleFlag(unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: ParticleFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_flags(self.raw.as_ptr(), value.0) }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2ParticleEmitter_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn bone_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_boneId(self.raw.as_ptr()) }
    }

    pub fn set_bone_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_boneId(self.raw.as_ptr(), value) }
    }

    pub fn particle_model_filename(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(
                ffi::whiteout_m2_M2ParticleEmitter_get_particleModelFilename(self.raw.as_ptr()),
            )
        }
    }

    pub fn set_particle_model_filename(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_particleModelFilename(
                self.raw.as_ptr(),
                value.as_ptr(),
            )
        }
    }

    pub fn child_emitters_model_filename(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(
                ffi::whiteout_m2_M2ParticleEmitter_get_childEmittersModelFilename(
                    self.raw.as_ptr(),
                ),
            )
        }
    }

    pub fn set_child_emitters_model_filename(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_childEmittersModelFilename(
                self.raw.as_ptr(),
                value.as_ptr(),
            )
        }
    }

    pub fn blending_type(&self) -> ParticleBlending {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_blendingType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_blending_type(&mut self, value: ParticleBlending) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_blendingType(self.raw.as_ptr(), value as i32)
        }
    }

    pub fn emitter_type(&self) -> ParticleEmitterType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_emitterType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_emitter_type(&mut self, value: ParticleEmitterType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_emitterType(self.raw.as_ptr(), value as i32)
        }
    }

    pub fn particle_color_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_particleColorIndex(self.raw.as_ptr()) }
    }

    pub fn set_particle_color_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_particleColorIndex(self.raw.as_ptr(), value)
        }
    }

    pub fn particle_type(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_particleType(self.raw.as_ptr()) }
    }

    pub fn set_particle_type(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_particleType(self.raw.as_ptr(), value) }
    }

    pub fn head_or_tail(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_headOrTail(self.raw.as_ptr()) }
    }

    pub fn set_head_or_tail(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_headOrTail(self.raw.as_ptr(), value) }
    }

    pub fn texture_tilerotation(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_textureTilerotation(self.raw.as_ptr()) }
    }

    pub fn set_texture_tilerotation(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_textureTilerotation(self.raw.as_ptr(), value)
        }
    }

    pub fn rows(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_rows(self.raw.as_ptr()) }
    }

    pub fn set_rows(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_rows(self.raw.as_ptr(), value) }
    }

    pub fn columns(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_columns(self.raw.as_ptr()) }
    }

    pub fn set_columns(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_columns(self.raw.as_ptr(), value) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn emission_speed(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionSpeed(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn emission_speed_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionSpeed(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn speed_variation(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_speedVariation(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn speed_variation_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_speedVariation(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn vertical_range(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_verticalRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn vertical_range_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_verticalRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn horizontal_range(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_horizontalRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn horizontal_range_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_horizontalRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn gravity(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_gravity(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn gravity_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_gravity(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn lifespan(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_lifespan(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn lifespan_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_lifespan(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn lifespan_variation(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_lifespanVariation(self.raw.as_ptr()) }
    }

    pub fn set_lifespan_variation(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_lifespanVariation(self.raw.as_ptr(), value)
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn emission_rate(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionRate(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn emission_rate_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionRate(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn emission_rate_variation(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_emissionRateVariation(self.raw.as_ptr()) }
    }

    pub fn set_emission_rate_variation(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_emissionRateVariation(self.raw.as_ptr(), value)
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn emission_area_width(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionAreaWidth(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn emission_area_width_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionAreaWidth(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn emission_area_length(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionAreaLength(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn emission_area_length_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_emissionAreaLength(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn z_source(&self) -> crate::support::Ref<'_, AnimationTrackF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_zSource(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn z_source_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_zSource(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn color_track(&self) -> crate::support::Ref<'_, ParticleAnimationTrackVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(ParticleAnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_colorTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn color_track_mut(
        &mut self,
    ) -> crate::support::RefMut<'_, ParticleAnimationTrackVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(ParticleAnimationTrackVector3f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_colorTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn scale_track(&self) -> crate::support::Ref<'_, ParticleAnimationTrackVector2f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(ParticleAnimationTrackVector2f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_scaleTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn scale_track_mut(
        &mut self,
    ) -> crate::support::RefMut<'_, ParticleAnimationTrackVector2f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(ParticleAnimationTrackVector2f {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_scaleTrack(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn scale_vary(&self) -> crate::math::Vector2f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2ParticleEmitter_get_scaleVary(self.raw.as_ptr())
                as *const crate::math::Vector2f)
        }
    }

    pub fn set_scale_vary(&mut self, value: crate::math::Vector2f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_scaleVary(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector2f as *const _,
            )
        }
    }

    pub fn tail_length(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_tailLength(self.raw.as_ptr()) }
    }

    pub fn set_tail_length(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_tailLength(self.raw.as_ptr(), value) }
    }

    pub fn twinkle_speed(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_twinkleSpeed(self.raw.as_ptr()) }
    }

    pub fn set_twinkle_speed(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_twinkleSpeed(self.raw.as_ptr(), value) }
    }

    pub fn twinkle_percent(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_twinklePercent(self.raw.as_ptr()) }
    }

    pub fn set_twinkle_percent(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_twinklePercent(self.raw.as_ptr(), value) }
    }

    pub fn twinkle_scale(&self) -> crate::math::Vector2f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2ParticleEmitter_get_twinkleScale(self.raw.as_ptr())
                as *const crate::math::Vector2f)
        }
    }

    pub fn set_twinkle_scale(&mut self, value: crate::math::Vector2f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_twinkleScale(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector2f as *const _,
            )
        }
    }

    pub fn inherit_velocity_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_inheritVelocityScale(self.raw.as_ptr()) }
    }

    pub fn set_inherit_velocity_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_inheritVelocityScale(self.raw.as_ptr(), value)
        }
    }

    pub fn drag(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_drag(self.raw.as_ptr()) }
    }

    pub fn set_drag(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_drag(self.raw.as_ptr(), value) }
    }

    pub fn base_spin(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_baseSpin(self.raw.as_ptr()) }
    }

    pub fn set_base_spin(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_baseSpin(self.raw.as_ptr(), value) }
    }

    pub fn base_spin_variation(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_baseSpinVariation(self.raw.as_ptr()) }
    }

    pub fn set_base_spin_variation(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_baseSpinVariation(self.raw.as_ptr(), value)
        }
    }

    pub fn spin_speed(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_spinSpeed(self.raw.as_ptr()) }
    }

    pub fn set_spin_speed(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_spinSpeed(self.raw.as_ptr(), value) }
    }

    pub fn spin_speed_variation(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_spinSpeedVariation(self.raw.as_ptr()) }
    }

    pub fn set_spin_speed_variation(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_spinSpeedVariation(self.raw.as_ptr(), value)
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn tumble(&self) -> crate::support::Ref<'_, Box> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(Box {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_tumble(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn tumble_mut(&mut self) -> crate::support::RefMut<'_, Box> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(Box {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_tumble(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn wind_vector(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2ParticleEmitter_get_windVector(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_wind_vector(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_set_windVector(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn wind_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_windTime(self.raw.as_ptr()) }
    }

    pub fn set_wind_time(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_windTime(self.raw.as_ptr(), value) }
    }

    pub fn follow_speed_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_followSpeed1(self.raw.as_ptr()) }
    }

    pub fn set_follow_speed_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_followSpeed1(self.raw.as_ptr(), value) }
    }

    pub fn follow_scale_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_followScale1(self.raw.as_ptr()) }
    }

    pub fn set_follow_scale_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_followScale1(self.raw.as_ptr(), value) }
    }

    pub fn follow_speed_2(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_followSpeed2(self.raw.as_ptr()) }
    }

    pub fn set_follow_speed_2(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_followSpeed2(self.raw.as_ptr(), value) }
    }

    pub fn follow_scale_2(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_get_followScale2(self.raw.as_ptr()) }
    }

    pub fn set_follow_scale_2(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_set_followScale2(self.raw.as_ptr(), value) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn spline_points(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleEmitter_get_splinePoints_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2ParticleEmitter_get_splinePoints_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn spline_points_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleEmitter_get_splinePoints_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2ParticleEmitter_get_splinePoints_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_spline_points(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2ParticleEmitter_assign_splinePoints(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_spline_points(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2ParticleEmitter_resize_splinePoints(self.raw.as_ptr(), count) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn enabled_in(&self) -> crate::support::Ref<'_, AnimationTrackU8> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_enabledIn(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn enabled_in_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackU8> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackU8 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ParticleEmitter_get_enabledIn(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for ParticleEmitter {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Event {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Event>,
}

impl Drop for Event {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Event_delete(self.raw.as_ptr()) }
    }
}

impl Event {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Event) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Event { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Event {}

impl core::fmt::Debug for Event {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Event").finish_non_exhaustive()
    }
}

impl Event {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Event_new();
            Self::from_raw(raw).expect("native Event allocation failed")
        }
    }

    pub fn identifier(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_get_identifier(self.raw.as_ptr()) }
    }

    pub fn set_identifier(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_set_identifier(self.raw.as_ptr(), value) }
    }

    pub fn data(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_get_data(self.raw.as_ptr()) }
    }

    pub fn set_data(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_set_data(self.raw.as_ptr(), value) }
    }

    pub fn bone_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_get_boneId(self.raw.as_ptr()) }
    }

    pub fn set_bone_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Event_set_boneId(self.raw.as_ptr(), value) }
    }

    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2Event_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2Event_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn enabled(&self) -> crate::support::Ref<'_, AnimationTrackBase> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimationTrackBase {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Event_get_enabled(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn enabled_mut(&mut self) -> crate::support::RefMut<'_, AnimationTrackBase> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimationTrackBase {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Event_get_enabled(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Event {
    fn default() -> Self {
        Self::new()
    }
}

/// The affine frame the Domino chunks store: three basis columns and an origin, twelve floats in all.
///
/// The client reassembles it as `dmMtx{axisX, axisY, axisZ}` -> `dmQuatFromMtx` plus `origin` as the translation, giving a `dmTransform`.
pub struct PhysicsFrame {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsFrame>,
}

impl Drop for PhysicsFrame {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsFrame_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsFrame {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsFrame) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsFrame { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsFrame {}

impl core::fmt::Debug for PhysicsFrame {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsFrame").finish_non_exhaustive()
    }
}

impl PhysicsFrame {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsFrame_new();
            Self::from_raw(raw).expect("native PhysicsFrame allocation failed")
        }
    }

    pub fn axis_x(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PhysicsFrame_get_axisX(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_axis_x(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PhysicsFrame_set_axisX(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn axis_y(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PhysicsFrame_get_axisY(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_axis_y(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PhysicsFrame_set_axisY(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn axis_z(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PhysicsFrame_get_axisZ(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_axis_z(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PhysicsFrame_set_axisZ(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn origin(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PhysicsFrame_get_origin(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_origin(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PhysicsFrame_set_origin(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for PhysicsFrame {
    fn default() -> Self {
        Self::new()
    }
}

/// One rigid body, bound to a single model bone — BODY/BDY2/BDY3/BDY4.
///
/// The four on-disk layouts are the same fields accreting over time, so they share one struct; PhysicsData::version decides which of them is written back, and fields the older layouts lack keep their defaults.
pub struct PhysicsBody {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsBody>,
}

impl Drop for PhysicsBody {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsBody {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsBody) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsBody { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsBody {}

impl core::fmt::Debug for PhysicsBody {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsBody").finish_non_exhaustive()
    }
}

impl PhysicsBody {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsBody_new();
            Self::from_raw(raw).expect("native PhysicsBody allocation failed")
        }
    }

    pub fn type_(&self) -> PhysicsBodyType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_type(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_type_(&mut self, value: PhysicsBodyType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_type(self.raw.as_ptr(), value as i32) }
    }

    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Offset from the bone's animated position, not an absolute position: the client spawns the body at `bonePosition + position`.
    pub fn position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PhysicsBody_get_position(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PhysicsBody_set_position(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// First entry in PhysicsData::shapes belonging to this body. 32 bits wide in BODY/BDY2, 16 from BDY3 on — writing a larger index back into one of those truncates it.
    pub fn shape_index(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_shapeIndex(self.raw.as_ptr()) }
    }

    pub fn set_shape_index(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_shapeIndex(self.raw.as_ptr(), value) }
    }

    pub fn shape_count(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_shapeCount(self.raw.as_ptr()) }
    }

    pub fn set_shape_count(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_shapeCount(self.raw.as_ptr(), value) }
    }

    /// BDY3+. 1.0 on all but 45 of 1213 kinematic bodies but tuned freely on dynamic ones, negatives included — the shape of `dmBodyDef::m_gravityScale`.
    pub fn gravity_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_gravityScale(self.raw.as_ptr()) }
    }

    pub fn set_gravity_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_gravityScale(self.raw.as_ptr(), value) }
    }

    /// BDY2+. 1.0 in 3457 of 3526 bodies, otherwise 1.1-10 — `dmBodyDef::m_inertiaScale`.
    pub fn inertia_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_inertiaScale(self.raw.as_ptr()) }
    }

    pub fn set_inertia_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_inertiaScale(self.raw.as_ptr(), value) }
    }

    /// BDY3+. Zero on 1196 of 1213 kinematic bodies and 0-10 on dynamic ones — `dmBodyDef::m_linearDamping`.
    pub fn linear_damping(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_linearDamping(self.raw.as_ptr()) }
    }

    pub fn set_linear_damping(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_linearDamping(self.raw.as_ptr(), value) }
    }

    /// BDY3+. Same kinematic/dynamic split as @ref linearDamping — `dmBodyDef::m_angularDamping`.
    pub fn angular_damping(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_angularDamping(self.raw.as_ptr()) }
    }

    pub fn set_angular_damping(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_angularDamping(self.raw.as_ptr(), value) }
    }

    /// BDY3+. Unidentified. Unlike the four above it is set on kinematic and dynamic bodies alike, so it is not a rigid-body integration parameter; values cluster on 0.5, 0.01, 0.9 and 0.1.
    pub fn unknown_28(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_unknown28(self.raw.as_ptr()) }
    }

    pub fn set_unknown_28(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_unknown28(self.raw.as_ptr(), value) }
    }

    /// BDY4+. Unidentified; 0 in half the corpus, otherwise small values or 0x8000 alone, which reads like a bit field.
    pub fn unknown_2c(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_unknown2c(self.raw.as_ptr()) }
    }

    pub fn set_unknown_2c(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_unknown2c(self.raw.as_ptr(), value) }
    }

    /// BDY4+. Zero in every corpus body.
    pub fn padding_2e(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_get_padding2e(self.raw.as_ptr()) }
    }

    pub fn set_padding_2e(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsBody_set_padding2e(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsBody {
    fn default() -> Self {
        Self::new()
    }
}

/// One collision shape reference — SHAP/SHP2. Points at an entry of the box/capsule/sphere/polytope array named by @ref shapeType.
pub struct PhysicsShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsShape>,
}

impl Drop for PhysicsShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsShape {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsShape { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsShape {}

impl core::fmt::Debug for PhysicsShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsShape").finish_non_exhaustive()
    }
}

impl PhysicsShape {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsShape_new();
            Self::from_raw(raw).expect("native PhysicsShape allocation failed")
        }
    }

    pub fn shape_type(&self) -> PhysicsShapeType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_shapeType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_shape_type(&mut self, value: PhysicsShapeType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_shapeType(self.raw.as_ptr(), value as i32) }
    }

    pub fn shape_index(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_shapeIndex(self.raw.as_ptr()) }
    }

    pub fn set_shape_index(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_shapeIndex(self.raw.as_ptr(), value) }
    }

    /// Zero in every corpus shape.
    pub fn padding_04(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_padding04(self.raw.as_ptr()) }
    }

    pub fn set_padding_04(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_padding04(self.raw.as_ptr(), value) }
    }

    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_friction(self.raw.as_ptr()) }
    }

    pub fn set_friction(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_friction(self.raw.as_ptr(), value) }
    }

    pub fn restitution(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_restitution(self.raw.as_ptr()) }
    }

    pub fn set_restitution(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_restitution(self.raw.as_ptr(), value) }
    }

    pub fn density(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_density(self.raw.as_ptr()) }
    }

    pub fn set_density(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_density(self.raw.as_ptr(), value) }
    }

    /// SHP2+. Unidentified, but a float: only 0, 0.01, 0.8 and 1.0 occur. The one `dmFixtureDef` float the rest of this struct does not account for is `m_rollingResistance`.
    pub fn unknown_14(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_unknown14(self.raw.as_ptr()) }
    }

    pub fn set_unknown_14(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_unknown14(self.raw.as_ptr(), value) }
    }

    /// SHP2+. 1.0 in 3229 of 3230 shapes, matching the `m_scaleOrRadius` the client hands every fixture.
    pub fn scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_scale(self.raw.as_ptr()) }
    }

    pub fn set_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_scale(self.raw.as_ptr(), value) }
    }

    /// SHP2+. Zero in every corpus shape.
    pub fn unknown_1c(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_unknown1c(self.raw.as_ptr()) }
    }

    pub fn set_unknown_1c(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_unknown1c(self.raw.as_ptr(), value) }
    }

    /// SHP2+. Uninitialised on disk; kept so writes match.
    pub fn padding_1e(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_get_padding1e(self.raw.as_ptr()) }
    }

    pub fn set_padding_1e(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsShape_set_padding1e(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsShape {
    fn default() -> Self {
        Self::new()
    }
}

/// BOXS — an oriented box. The client turns it straight into a polytope via `CPhysicsBoxShapeDef::SetPolytopeData(frame, halfExtents)`.
pub struct BoxShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2BoxShape>,
}

impl Drop for BoxShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2BoxShape_delete(self.raw.as_ptr()) }
    }
}

impl BoxShape {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2BoxShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| BoxShape { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for BoxShape {}

impl core::fmt::Debug for BoxShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BoxShape").finish_non_exhaustive()
    }
}

impl BoxShape {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2BoxShape_new();
            Self::from_raw(raw).expect("native BoxShape allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2BoxShape_get_frame(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn frame_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2BoxShape_get_frame(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn half_extents(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2BoxShape_get_halfExtents(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_half_extents(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2BoxShape_set_halfExtents(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for BoxShape {
    fn default() -> Self {
        Self::new()
    }
}

/// CAPS — a capsule between two local points.
pub struct CapsuleShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2CapsuleShape>,
}

impl Drop for CapsuleShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2CapsuleShape_delete(self.raw.as_ptr()) }
    }
}

impl CapsuleShape {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2CapsuleShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CapsuleShape { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for CapsuleShape {}

impl core::fmt::Debug for CapsuleShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("CapsuleShape").finish_non_exhaustive()
    }
}

impl CapsuleShape {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2CapsuleShape_new();
            Self::from_raw(raw).expect("native CapsuleShape allocation failed")
        }
    }

    pub fn local_position_1(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2CapsuleShape_get_localPosition1(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_position_1(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2CapsuleShape_set_localPosition1(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn local_position_2(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2CapsuleShape_get_localPosition2(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_position_2(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2CapsuleShape_set_localPosition2(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2CapsuleShape_get_radius(self.raw.as_ptr()) }
    }

    pub fn set_radius(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2CapsuleShape_set_radius(self.raw.as_ptr(), value) }
    }
}

impl Default for CapsuleShape {
    fn default() -> Self {
        Self::new()
    }
}

/// SPHS — a sphere at a local point.
pub struct SphereShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2SphereShape>,
}

impl Drop for SphereShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2SphereShape_delete(self.raw.as_ptr()) }
    }
}

impl SphereShape {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2SphereShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SphereShape { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for SphereShape {}

impl core::fmt::Debug for SphereShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SphereShape").finish_non_exhaustive()
    }
}

impl SphereShape {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2SphereShape_new();
            Self::from_raw(raw).expect("native SphereShape allocation failed")
        }
    }

    pub fn local_position(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2SphereShape_get_localPosition(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_position(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2SphereShape_set_localPosition(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SphereShape_get_radius(self.raw.as_ptr()) }
    }

    pub fn set_radius(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SphereShape_set_radius(self.raw.as_ptr(), value) }
    }
}

impl Default for SphereShape {
    fn default() -> Self {
        Self::new()
    }
}

/// One half-edge of a polytope — Domino's `dmSubEdge`, four bytes.
///
/// Half-edges are stored in twin pairs at adjacent indices, and the ones bounding a face form a cycle through @ref nextEdge.
pub struct PolytopeHalfEdge {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PolytopeHalfEdge>,
}

impl Drop for PolytopeHalfEdge {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_delete(self.raw.as_ptr()) }
    }
}

impl PolytopeHalfEdge {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PolytopeHalfEdge) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PolytopeHalfEdge { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PolytopeHalfEdge {}

impl core::fmt::Debug for PolytopeHalfEdge {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PolytopeHalfEdge").finish_non_exhaustive()
    }
}

impl PolytopeHalfEdge {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PolytopeHalfEdge_new();
            Self::from_raw(raw).expect("native PolytopeHalfEdge allocation failed")
        }
    }

    /// Signed step to the paired half-edge: the twin of edge `i` is `i + twinOffset`. Only +1 and -1 occur, in equal numbers.
    pub fn twin_offset(&self) -> i8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_get_twinOffset(self.raw.as_ptr()) }
    }

    pub fn set_twin_offset(&mut self, value: i8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_set_twinOffset(self.raw.as_ptr(), value) }
    }

    /// Where this half-edge starts, indexing PolytopeShape::vertices.
    pub fn origin_vertex(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_get_originVertex(self.raw.as_ptr()) }
    }

    pub fn set_origin_vertex(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_set_originVertex(self.raw.as_ptr(), value) }
    }

    /// The face this half-edge bounds, indexing PolytopeShape::facePlanes.
    pub fn face_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_get_faceIndex(self.raw.as_ptr()) }
    }

    pub fn set_face_index(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_set_faceIndex(self.raw.as_ptr(), value) }
    }

    /// Next half-edge around @ref faceIndex.
    pub fn next_edge(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_get_nextEdge(self.raw.as_ptr()) }
    }

    pub fn set_next_edge(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeHalfEdge_set_nextEdge(self.raw.as_ptr(), value) }
    }
}

impl Default for PolytopeHalfEdge {
    fn default() -> Self {
        Self::new()
    }
}

/// PLYT — a convex hull, version 3+. Domino's `dmPolytope`.
///
/// The chunk stores fixed-size headers and variable-size payloads in two blocks; both halves are folded into this one struct, and the header's counts are recomputed from the vectors on write. The header's four pointer fields are filled in by the client at load time and are zero in every file, so they are not kept.
pub struct PolytopeShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PolytopeShape>,
}

impl Drop for PolytopeShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_delete(self.raw.as_ptr()) }
    }
}

impl PolytopeShape {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PolytopeShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PolytopeShape { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PolytopeShape {}

impl core::fmt::Debug for PolytopeShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PolytopeShape").finish_non_exhaustive()
    }
}

impl PolytopeShape {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PolytopeShape_new();
            Self::from_raw(raw).expect("native PolytopeShape allocation failed")
        }
    }

    /// Hull corners.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn vertices(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_vertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_vertices_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn vertices_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_vertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_vertices_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_vertices(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PolytopeShape_assign_vertices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vertices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_resize_vertices(self.raw.as_ptr(), count) }
    }

    /// Outward plane of each face, `xyz` normal and `w` offset.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn face_planes(&self) -> &[crate::math::Vector4f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_facePlanes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_facePlanes_data(self.raw.as_ptr())
                as *const crate::math::Vector4f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn face_planes_mut(&mut self) -> &mut [crate::math::Vector4f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_facePlanes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_facePlanes_data(self.raw.as_ptr())
                as *const crate::math::Vector4f as *mut crate::math::Vector4f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_face_planes(&mut self, values: &[crate::math::Vector4f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PolytopeShape_assign_facePlanes(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_face_planes(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_resize_facePlanes(self.raw.as_ptr(), count) }
    }

    /// One entry per face: any half-edge bounding it, as the entry point for walking the face through PolytopeHalfEdge::nextEdge.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn face_first_edges(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_faceFirstEdges_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_faceFirstEdges_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn face_first_edges_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PolytopeShape_get_faceFirstEdges_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PolytopeShape_get_faceFirstEdges_data(self.raw.as_ptr())
                as *mut u8;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_face_first_edges(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PolytopeShape_assign_faceFirstEdges(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_face_first_edges(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_resize_faceFirstEdges(self.raw.as_ptr(), count) }
    }

    pub fn edges_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_edges_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn edges(&self, index: usize) -> Option<crate::support::Ref<'_, PolytopeHalfEdge>> {
        if index >= self.edges_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PolytopeHalfEdge {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PolytopeShape_get_edges_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn edges_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PolytopeHalfEdge>> {
        if index >= self.edges_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PolytopeHalfEdge {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PolytopeShape_get_edges_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn edges_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PolytopeHalfEdge>> {
        (0..self.edges_len()).map(move |i| self.edges(i).expect("index below len"))
    }

    pub fn resize_edges(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_resize_edges(self.raw.as_ptr(), count) }
    }

    /// Volume-weighted, not the vertex average.
    pub fn centroid(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2PolytopeShape_get_centroid(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_centroid(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2PolytopeShape_set_centroid(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Hull volume.
    pub fn volume(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_volume(self.raw.as_ptr()) }
    }

    pub fn set_volume(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_volume(self.raw.as_ptr(), value) }
    }

    /// Hull surface area.
    pub fn surface_area(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_surfaceArea(self.raw.as_ptr()) }
    }

    pub fn set_surface_area(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_surfaceArea(self.raw.as_ptr(), value) }
    }

    /// The four-byte gaps each count leaves in front of its 64-bit pointer, and the one that trails the header. Uninitialised in the files — some carry fragments of unrelated strings — so they are kept verbatim for writing.
    pub fn padding_04(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_padding04(self.raw.as_ptr()) }
    }

    pub fn set_padding_04(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_padding04(self.raw.as_ptr(), value) }
    }

    pub fn padding_14(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_padding14(self.raw.as_ptr()) }
    }

    pub fn set_padding_14(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_padding14(self.raw.as_ptr(), value) }
    }

    pub fn padding_2c(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_padding2c(self.raw.as_ptr()) }
    }

    pub fn set_padding_2c(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_padding2c(self.raw.as_ptr(), value) }
    }

    pub fn padding_4c(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_get_padding4c(self.raw.as_ptr()) }
    }

    pub fn set_padding_4c(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PolytopeShape_set_padding4c(self.raw.as_ptr(), value) }
    }
}

impl Default for PolytopeShape {
    fn default() -> Self {
        Self::new()
    }
}

/// JOIN — connects two bodies with the joint named by @ref jointType.
pub struct PhysicsJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsJoint>,
}

impl Drop for PhysicsJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsJoint {}

impl core::fmt::Debug for PhysicsJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsJoint").finish_non_exhaustive()
    }
}

impl PhysicsJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsJoint_new();
            Self::from_raw(raw).expect("native PhysicsJoint allocation failed")
        }
    }

    pub fn body_a_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_get_bodyAIndex(self.raw.as_ptr()) }
    }

    pub fn set_body_a_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_set_bodyAIndex(self.raw.as_ptr(), value) }
    }

    pub fn body_b_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_get_bodyBIndex(self.raw.as_ptr()) }
    }

    pub fn set_body_b_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_set_bodyBIndex(self.raw.as_ptr(), value) }
    }

    /// Zero in every corpus joint.
    pub fn padding_08(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_get_padding08(self.raw.as_ptr()) }
    }

    pub fn set_padding_08(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_set_padding08(self.raw.as_ptr(), value) }
    }

    pub fn joint_type(&self) -> PhysicsJointType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_get_jointType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_joint_type(&mut self, value: PhysicsJointType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_set_jointType(self.raw.as_ptr(), value as i32) }
    }

    /// Entry index within the joint array @ref jointType selects.
    pub fn joint_id(&self) -> i16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_get_jointId(self.raw.as_ptr()) }
    }

    pub fn set_joint_id(&mut self, value: i16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsJoint_set_jointId(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// WELJ/WLJ2/WLJ3 — a soft rigid connection. Zero frequency means the axis is solved as a hard constraint.
pub struct WeldJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2WeldJoint>,
}

impl Drop for WeldJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2WeldJoint_delete(self.raw.as_ptr()) }
    }
}

impl WeldJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2WeldJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| WeldJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for WeldJoint {}

impl core::fmt::Debug for WeldJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("WeldJoint").finish_non_exhaustive()
    }
}

impl WeldJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2WeldJoint_new();
            Self::from_raw(raw).expect("native WeldJoint allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_a(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2WeldJoint_get_frameA(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn frame_a_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2WeldJoint_get_frameA(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_b(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2WeldJoint_get_frameB(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn frame_b_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2WeldJoint_get_frameB(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn angular_frequency_hz(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_get_angularFrequencyHz(self.raw.as_ptr()) }
    }

    pub fn set_angular_frequency_hz(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_set_angularFrequencyHz(self.raw.as_ptr(), value) }
    }

    pub fn angular_damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_get_angularDampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_angular_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_set_angularDampingRatio(self.raw.as_ptr(), value) }
    }

    /// WLJ2+
    pub fn linear_frequency_hz(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_get_linearFrequencyHz(self.raw.as_ptr()) }
    }

    pub fn set_linear_frequency_hz(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_set_linearFrequencyHz(self.raw.as_ptr(), value) }
    }

    /// WLJ2+
    pub fn linear_damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_get_linearDampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_linear_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_set_linearDampingRatio(self.raw.as_ptr(), value) }
    }

    /// WLJ3+. Zero in 265 of 274 weld joints.
    pub fn unknown_70(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_get_unknown70(self.raw.as_ptr()) }
    }

    pub fn set_unknown_70(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WeldJoint_set_unknown70(self.raw.as_ptr(), value) }
    }
}

impl Default for WeldJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// SPHJ — a ball joint between two anchor points.
pub struct SphericalJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2SphericalJoint>,
}

impl Drop for SphericalJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2SphericalJoint_delete(self.raw.as_ptr()) }
    }
}

impl SphericalJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2SphericalJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SphericalJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for SphericalJoint {}

impl core::fmt::Debug for SphericalJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SphericalJoint").finish_non_exhaustive()
    }
}

impl SphericalJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2SphericalJoint_new();
            Self::from_raw(raw).expect("native SphericalJoint allocation failed")
        }
    }

    pub fn anchor_a(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2SphericalJoint_get_anchorA(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_anchor_a(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2SphericalJoint_set_anchorA(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn anchor_b(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2SphericalJoint_get_anchorB(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_anchor_b(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2SphericalJoint_set_anchorB(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn friction_torque(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2SphericalJoint_get_frictionTorque(self.raw.as_ptr()) }
    }

    pub fn set_friction_torque(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2SphericalJoint_set_frictionTorque(self.raw.as_ptr(), value) }
    }
}

impl Default for SphericalJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// SHOJ/SHJ2 — a twist-and-cone joint, the one that chains cloth.
pub struct ShoulderJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ShoulderJoint>,
}

impl Drop for ShoulderJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_delete(self.raw.as_ptr()) }
    }
}

impl ShoulderJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2ShoulderJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ShoulderJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ShoulderJoint {}

impl core::fmt::Debug for ShoulderJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ShoulderJoint").finish_non_exhaustive()
    }
}

impl ShoulderJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ShoulderJoint_new();
            Self::from_raw(raw).expect("native ShoulderJoint allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_a(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ShoulderJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_a_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ShoulderJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_b(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ShoulderJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_b_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2ShoulderJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn lower_twist_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_lowerTwistAngle(self.raw.as_ptr()) }
    }

    pub fn set_lower_twist_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_lowerTwistAngle(self.raw.as_ptr(), value) }
    }

    pub fn upper_twist_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_upperTwistAngle(self.raw.as_ptr()) }
    }

    pub fn set_upper_twist_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_upperTwistAngle(self.raw.as_ptr(), value) }
    }

    /// Degrees: the corpus holds 20, 35, 45 and 60, while `dmShoulderJoint` clamps its own cone to [10°, 170°] expressed in radians — so the loader converts on the way in.
    pub fn cone_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_coneAngle(self.raw.as_ptr()) }
    }

    pub fn set_cone_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_coneAngle(self.raw.as_ptr(), value) }
    }

    /// version 2+
    pub fn max_motor_torque(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_maxMotorTorque(self.raw.as_ptr()) }
    }

    pub fn set_max_motor_torque(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_maxMotorTorque(self.raw.as_ptr(), value) }
    }

    /// version 2+
    pub fn motor_mode(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_motorMode(self.raw.as_ptr()) }
    }

    pub fn set_motor_mode(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_motorMode(self.raw.as_ptr(), value) }
    }

    /// SHJ2
    pub fn motor_frequency_hz(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_motorFrequencyHz(self.raw.as_ptr()) }
    }

    pub fn set_motor_frequency_hz(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_motorFrequencyHz(self.raw.as_ptr(), value) }
    }

    /// SHJ2
    pub fn motor_damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_get_motorDampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_motor_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2ShoulderJoint_set_motorDampingRatio(self.raw.as_ptr(), value) }
    }
}

impl Default for ShoulderJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// PRSJ/PRS2 — a sliding joint, version 2+.
pub struct PrismaticJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PrismaticJoint>,
}

impl Drop for PrismaticJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_delete(self.raw.as_ptr()) }
    }
}

impl PrismaticJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PrismaticJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PrismaticJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PrismaticJoint {}

impl core::fmt::Debug for PrismaticJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PrismaticJoint").finish_non_exhaustive()
    }
}

impl PrismaticJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PrismaticJoint_new();
            Self::from_raw(raw).expect("native PrismaticJoint allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_a(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PrismaticJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_a_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PrismaticJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_b(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PrismaticJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_b_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PrismaticJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn lower_limit(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_lowerLimit(self.raw.as_ptr()) }
    }

    pub fn set_lower_limit(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_lowerLimit(self.raw.as_ptr(), value) }
    }

    pub fn upper_limit(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_upperLimit(self.raw.as_ptr()) }
    }

    pub fn set_upper_limit(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_upperLimit(self.raw.as_ptr(), value) }
    }

    /// Unidentified; zero in all twelve corpus prismatic joints. Domino's prismatic def carries an enable-limit flag next to the limit pair.
    pub fn unknown_68(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_unknown68(self.raw.as_ptr()) }
    }

    pub fn set_unknown_68(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_unknown68(self.raw.as_ptr(), value) }
    }

    pub fn max_motor_force(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_maxMotorForce(self.raw.as_ptr()) }
    }

    pub fn set_max_motor_force(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_maxMotorForce(self.raw.as_ptr(), value) }
    }

    /// Unidentified; zero in all twelve.
    pub fn unknown_70(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_unknown70(self.raw.as_ptr()) }
    }

    pub fn set_unknown_70(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_unknown70(self.raw.as_ptr(), value) }
    }

    pub fn motor_mode(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_motorMode(self.raw.as_ptr()) }
    }

    pub fn set_motor_mode(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_motorMode(self.raw.as_ptr(), value) }
    }

    /// PRS2
    pub fn motor_frequency_hz(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_motorFrequencyHz(self.raw.as_ptr()) }
    }

    pub fn set_motor_frequency_hz(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_motorFrequencyHz(self.raw.as_ptr(), value) }
    }

    /// PRS2
    pub fn motor_damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_get_motorDampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_motor_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PrismaticJoint_set_motorDampingRatio(self.raw.as_ptr(), value) }
    }
}

impl Default for PrismaticJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// REVJ/REV2 — a hinge, version 2+.
pub struct RevoluteJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2RevoluteJoint>,
}

impl Drop for RevoluteJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_delete(self.raw.as_ptr()) }
    }
}

impl RevoluteJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2RevoluteJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| RevoluteJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for RevoluteJoint {}

impl core::fmt::Debug for RevoluteJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RevoluteJoint").finish_non_exhaustive()
    }
}

impl RevoluteJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2RevoluteJoint_new();
            Self::from_raw(raw).expect("native RevoluteJoint allocation failed")
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_a(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RevoluteJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_a_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RevoluteJoint_get_frameA(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn frame_b(&self) -> crate::support::Ref<'_, PhysicsFrame> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RevoluteJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn frame_b_mut(&mut self) -> crate::support::RefMut<'_, PhysicsFrame> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(PhysicsFrame {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2RevoluteJoint_get_frameB(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn lower_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_lowerAngle(self.raw.as_ptr()) }
    }

    pub fn set_lower_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_lowerAngle(self.raw.as_ptr(), value) }
    }

    pub fn upper_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_upperAngle(self.raw.as_ptr()) }
    }

    pub fn set_upper_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_upperAngle(self.raw.as_ptr(), value) }
    }

    pub fn max_motor_torque(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_maxMotorTorque(self.raw.as_ptr()) }
    }

    pub fn set_max_motor_torque(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_maxMotorTorque(self.raw.as_ptr(), value) }
    }

    /// 1: position mode (frequency > 0), 2: velocity mode.
    pub fn motor_mode(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_motorMode(self.raw.as_ptr()) }
    }

    pub fn set_motor_mode(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_motorMode(self.raw.as_ptr(), value) }
    }

    /// REV2
    pub fn motor_frequency_hz(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_motorFrequencyHz(self.raw.as_ptr()) }
    }

    pub fn set_motor_frequency_hz(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_motorFrequencyHz(self.raw.as_ptr(), value) }
    }

    /// REV2
    pub fn motor_damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_get_motorDampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_motor_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2RevoluteJoint_set_motorDampingRatio(self.raw.as_ptr(), value) }
    }
}

impl Default for RevoluteJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// DSTJ — holds two anchors a fixed distance apart, version 2+.
pub struct DistanceJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2DistanceJoint>,
}

impl Drop for DistanceJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2DistanceJoint_delete(self.raw.as_ptr()) }
    }
}

impl DistanceJoint {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2DistanceJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DistanceJoint { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for DistanceJoint {}

impl core::fmt::Debug for DistanceJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DistanceJoint").finish_non_exhaustive()
    }
}

impl DistanceJoint {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2DistanceJoint_new();
            Self::from_raw(raw).expect("native DistanceJoint allocation failed")
        }
    }

    pub fn local_anchor_a(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2DistanceJoint_get_localAnchorA(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_anchor_a(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2DistanceJoint_set_localAnchorA(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn local_anchor_b(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m2_M2DistanceJoint_get_localAnchorB(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_anchor_b(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m2_M2DistanceJoint_set_localAnchorB(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    pub fn distance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceJoint_get_distance(self.raw.as_ptr()) }
    }

    pub fn set_distance(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2DistanceJoint_set_distance(self.raw.as_ptr(), value) }
    }
}

impl Default for DistanceJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// PHYV — six floats that overwrite the head of a tuning block the client otherwise fills with constants. Version 1+.
pub struct PhysicsTuning {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsTuning>,
}

impl Drop for PhysicsTuning {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsTuning_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsTuning {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsTuning) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsTuning { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsTuning {}

impl core::fmt::Debug for PhysicsTuning {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsTuning").finish_non_exhaustive()
    }
}

impl PhysicsTuning {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsTuning_new();
            Self::from_raw(raw).expect("native PhysicsTuning allocation failed")
        }
    }

    /// Number of elements — a fixed-size C++ array.
    pub const fn values_len() -> usize {
        6
    }

    /// # Panics
    /// If `index >= 6`, matching Rust slice indexing.
    pub fn values(&self, index: usize) -> f32 {
        assert!(index < 6, "values index {index} out of range (len 6)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2PhysicsTuning_get_values_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 6`.
    pub fn set_values(&mut self, index: usize, value: f32) {
        assert!(index < 6, "values index {index} out of range (len 6)");
        // SAFETY: index checked above.
        unsafe { ffi::whiteout_m2_M2PhysicsTuning_set_values_at(self.raw.as_ptr(), index, value) }
    }
}

impl Default for PhysicsTuning {
    fn default() -> Self {
        Self::new()
    }
}

/// A `.phys` chunk this library does not know, kept verbatim so a parse/write cycle does not drop it.
pub struct PhysicsUnknownChunk {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsUnknownChunk>,
}

impl Drop for PhysicsUnknownChunk {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsUnknownChunk_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsUnknownChunk {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsUnknownChunk) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsUnknownChunk { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsUnknownChunk {}

impl core::fmt::Debug for PhysicsUnknownChunk {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsUnknownChunk")
            .finish_non_exhaustive()
    }
}

impl PhysicsUnknownChunk {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsUnknownChunk_new();
            Self::from_raw(raw).expect("native PhysicsUnknownChunk allocation failed")
        }
    }

    /// FourCC as written on disk — `.phys` stores chunk ids reversed, so a PHYS chunk reads as "SYHP".
    /// Number of elements — a fixed-size C++ array.
    pub const fn tag_len() -> usize {
        4
    }

    /// # Panics
    /// If `index >= 4`, matching Rust slice indexing.
    pub fn tag(&self, index: usize) -> i8 {
        assert!(index < 4, "tag index {index} out of range (len 4)");
        // SAFETY: index checked above; plain scalar read.
        unsafe { ffi::whiteout_m2_M2PhysicsUnknownChunk_get_tag_at(self.raw.as_ptr(), index) }
    }

    /// # Panics
    /// If `index >= 4`.
    pub fn set_tag(&mut self, index: usize, value: i8) {
        assert!(index < 4, "tag index {index} out of range (len 4)");
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2PhysicsUnknownChunk_set_tag_at(self.raw.as_ptr(), index, value)
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn data(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsUnknownChunk_get_data_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2PhysicsUnknownChunk_get_data_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn data_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2PhysicsUnknownChunk_get_data_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2PhysicsUnknownChunk_get_data_data(self.raw.as_ptr()) as *mut u8;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_data(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2PhysicsUnknownChunk_assign_data(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_data(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsUnknownChunk_resize_data(self.raw.as_ptr(), count) }
    }
}

impl Default for PhysicsUnknownChunk {
    fn default() -> Self {
        Self::new()
    }
}

/// A whole `.phys` file — Blizzard's Domino rigid-body setup for a model, either a `.phys` sibling or an M2's inline PFDC chunk.
///
/// Bodies attach to bones and are linked by joints; each body owns a run of @ref shapes, and each shape indexes the array its type names.
pub struct PhysicsData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2PhysicsData>,
}

impl Drop for PhysicsData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2PhysicsData_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsData {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2PhysicsData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsData { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for PhysicsData {}

impl core::fmt::Debug for PhysicsData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsData").finish_non_exhaustive()
    }
}

impl PhysicsData {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2PhysicsData_new();
            Self::from_raw(raw).expect("native PhysicsData allocation failed")
        }
    }

    /// 0 (MoP) through 6. Decides which layout each chunk is written in — see the per-field version notes on the structs above.
    pub fn version(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_version(self.raw.as_ptr()) }
    }

    pub fn set_version(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_set_version(self.raw.as_ptr(), value) }
    }

    pub fn bodies_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_bodies_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn bodies(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsBody>> {
        if index >= self.bodies_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsBody {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_bodies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn bodies_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, PhysicsBody>> {
        if index >= self.bodies_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsBody {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_bodies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn bodies_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsBody>> {
        (0..self.bodies_len()).map(move |i| self.bodies(i).expect("index below len"))
    }

    pub fn resize_bodies(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_bodies(self.raw.as_ptr(), count) }
    }

    pub fn shapes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_shapes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn shapes(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsShape>> {
        if index >= self.shapes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_shapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn shapes_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, PhysicsShape>> {
        if index >= self.shapes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_shapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn shapes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsShape>> {
        (0..self.shapes_len()).map(move |i| self.shapes(i).expect("index below len"))
    }

    pub fn resize_shapes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_shapes(self.raw.as_ptr(), count) }
    }

    pub fn box_shapes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_boxShapes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn box_shapes(&self, index: usize) -> Option<crate::support::Ref<'_, BoxShape>> {
        if index >= self.box_shapes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(BoxShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_boxShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn box_shapes_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, BoxShape>> {
        if index >= self.box_shapes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(BoxShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_boxShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn box_shapes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, BoxShape>> {
        (0..self.box_shapes_len()).map(move |i| self.box_shapes(i).expect("index below len"))
    }

    pub fn resize_box_shapes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_boxShapes(self.raw.as_ptr(), count) }
    }

    pub fn capsule_shapes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_capsuleShapes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn capsule_shapes(&self, index: usize) -> Option<crate::support::Ref<'_, CapsuleShape>> {
        if index >= self.capsule_shapes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(CapsuleShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_capsuleShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn capsule_shapes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, CapsuleShape>> {
        if index >= self.capsule_shapes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(CapsuleShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_capsuleShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn capsule_shapes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, CapsuleShape>> {
        (0..self.capsule_shapes_len())
            .map(move |i| self.capsule_shapes(i).expect("index below len"))
    }

    pub fn resize_capsule_shapes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_capsuleShapes(self.raw.as_ptr(), count) }
    }

    pub fn sphere_shapes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_sphereShapes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn sphere_shapes(&self, index: usize) -> Option<crate::support::Ref<'_, SphereShape>> {
        if index >= self.sphere_shapes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SphereShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_sphereShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn sphere_shapes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SphereShape>> {
        if index >= self.sphere_shapes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SphereShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_sphereShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn sphere_shapes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SphereShape>> {
        (0..self.sphere_shapes_len()).map(move |i| self.sphere_shapes(i).expect("index below len"))
    }

    pub fn resize_sphere_shapes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_sphereShapes(self.raw.as_ptr(), count) }
    }

    pub fn polytope_shapes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_polytopeShapes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn polytope_shapes(&self, index: usize) -> Option<crate::support::Ref<'_, PolytopeShape>> {
        if index >= self.polytope_shapes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PolytopeShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_polytopeShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn polytope_shapes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PolytopeShape>> {
        if index >= self.polytope_shapes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PolytopeShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_polytopeShapes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn polytope_shapes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PolytopeShape>> {
        (0..self.polytope_shapes_len())
            .map(move |i| self.polytope_shapes(i).expect("index below len"))
    }

    pub fn resize_polytope_shapes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_polytopeShapes(self.raw.as_ptr(), count) }
    }

    pub fn joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_joints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn joints(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsJoint>> {
        if index >= self.joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_joints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn joints_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, PhysicsJoint>> {
        if index >= self.joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_joints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsJoint>> {
        (0..self.joints_len()).map(move |i| self.joints(i).expect("index below len"))
    }

    pub fn resize_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_joints(self.raw.as_ptr(), count) }
    }

    pub fn weld_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_weldJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn weld_joints(&self, index: usize) -> Option<crate::support::Ref<'_, WeldJoint>> {
        if index >= self.weld_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(WeldJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_weldJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn weld_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, WeldJoint>> {
        if index >= self.weld_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(WeldJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_weldJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn weld_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, WeldJoint>> {
        (0..self.weld_joints_len()).map(move |i| self.weld_joints(i).expect("index below len"))
    }

    pub fn resize_weld_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_weldJoints(self.raw.as_ptr(), count) }
    }

    pub fn spherical_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_sphericalJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn spherical_joints(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, SphericalJoint>> {
        if index >= self.spherical_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SphericalJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_sphericalJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn spherical_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SphericalJoint>> {
        if index >= self.spherical_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SphericalJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_sphericalJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn spherical_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SphericalJoint>> {
        (0..self.spherical_joints_len())
            .map(move |i| self.spherical_joints(i).expect("index below len"))
    }

    pub fn resize_spherical_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_sphericalJoints(self.raw.as_ptr(), count) }
    }

    pub fn shoulder_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_shoulderJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn shoulder_joints(&self, index: usize) -> Option<crate::support::Ref<'_, ShoulderJoint>> {
        if index >= self.shoulder_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ShoulderJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_shoulderJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn shoulder_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ShoulderJoint>> {
        if index >= self.shoulder_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ShoulderJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_shoulderJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn shoulder_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ShoulderJoint>> {
        (0..self.shoulder_joints_len())
            .map(move |i| self.shoulder_joints(i).expect("index below len"))
    }

    pub fn resize_shoulder_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_shoulderJoints(self.raw.as_ptr(), count) }
    }

    pub fn prismatic_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_prismaticJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn prismatic_joints(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, PrismaticJoint>> {
        if index >= self.prismatic_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PrismaticJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_prismaticJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn prismatic_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PrismaticJoint>> {
        if index >= self.prismatic_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PrismaticJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_prismaticJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn prismatic_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PrismaticJoint>> {
        (0..self.prismatic_joints_len())
            .map(move |i| self.prismatic_joints(i).expect("index below len"))
    }

    pub fn resize_prismatic_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_prismaticJoints(self.raw.as_ptr(), count) }
    }

    pub fn revolute_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_revoluteJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn revolute_joints(&self, index: usize) -> Option<crate::support::Ref<'_, RevoluteJoint>> {
        if index >= self.revolute_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(RevoluteJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_revoluteJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn revolute_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, RevoluteJoint>> {
        if index >= self.revolute_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(RevoluteJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_revoluteJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn revolute_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, RevoluteJoint>> {
        (0..self.revolute_joints_len())
            .map(move |i| self.revolute_joints(i).expect("index below len"))
    }

    pub fn resize_revolute_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_revoluteJoints(self.raw.as_ptr(), count) }
    }

    pub fn distance_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_distanceJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn distance_joints(&self, index: usize) -> Option<crate::support::Ref<'_, DistanceJoint>> {
        if index >= self.distance_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DistanceJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_distanceJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn distance_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DistanceJoint>> {
        if index >= self.distance_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DistanceJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_distanceJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn distance_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DistanceJoint>> {
        (0..self.distance_joints_len())
            .map(move |i| self.distance_joints(i).expect("index below len"))
    }

    pub fn resize_distance_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_distanceJoints(self.raw.as_ptr(), count) }
    }

    /// PHYV. A file that has one carries nothing else.
    pub fn tuning_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2PhysicsData_get_tuning_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn tuning(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsTuning>> {
        if index >= self.tuning_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsTuning {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_tuning_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn tuning_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PhysicsTuning>> {
        if index >= self.tuning_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsTuning {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2PhysicsData_get_tuning_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn tuning_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsTuning>> {
        (0..self.tuning_len()).map(move |i| self.tuning(i).expect("index below len"))
    }

    pub fn resize_tuning(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2PhysicsData_resize_tuning(self.raw.as_ptr(), count) }
    }
}

impl Default for PhysicsData {
    fn default() -> Self {
        Self::new()
    }
}

/// One bone's replacement transform, from a `.bone` file.
pub struct BoneOverride {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2BoneOverride>,
}

impl Drop for BoneOverride {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2BoneOverride_delete(self.raw.as_ptr()) }
    }
}

impl BoneOverride {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2BoneOverride) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| BoneOverride { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for BoneOverride {}

impl core::fmt::Debug for BoneOverride {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BoneOverride").finish_non_exhaustive()
    }
}

impl BoneOverride {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2BoneOverride_new();
            Self::from_raw(raw).expect("native BoneOverride allocation failed")
        }
    }

    /// Indexes Model::bones. Every id in the WoW corpus is below its model's bone count, and the ids within a file are strictly ascending.
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2BoneOverride_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2BoneOverride_set_boneIndex(self.raw.as_ptr(), value) }
    }
}

impl Default for BoneOverride {
    fn default() -> Self {
        Self::new()
    }
}

/// A whole `.bone` file: the skeleton edits one customization choice needs.
///
/// On disk this is two parallel chunks — `BIDA` holds the bone ids and `BOMT` the matrices — but their lengths match in every corpus file, so they are paired here and split again on write.
pub struct BoneOverrideSet {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2BoneOverrideSet>,
}

impl Drop for BoneOverrideSet {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2BoneOverrideSet_delete(self.raw.as_ptr()) }
    }
}

impl BoneOverrideSet {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2BoneOverrideSet) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| BoneOverrideSet { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for BoneOverrideSet {}

impl core::fmt::Debug for BoneOverrideSet {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BoneOverrideSet").finish_non_exhaustive()
    }
}

impl BoneOverrideSet {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2BoneOverrideSet_new();
            Self::from_raw(raw).expect("native BoneOverrideSet allocation failed")
        }
    }

    /// 1 in every known file.
    pub fn version(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2BoneOverrideSet_get_version(self.raw.as_ptr()) }
    }

    pub fn set_version(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2BoneOverrideSet_set_version(self.raw.as_ptr(), value) }
    }

    /// Ascending by @ref BoneOverride::boneIndex, which is the order the files store and what lets the client binary-search a bone.
    pub fn overrides_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2BoneOverrideSet_get_overrides_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn overrides(&self, index: usize) -> Option<crate::support::Ref<'_, BoneOverride>> {
        if index >= self.overrides_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(BoneOverride {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2BoneOverrideSet_get_overrides_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn overrides_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, BoneOverride>> {
        if index >= self.overrides_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(BoneOverride {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2BoneOverrideSet_get_overrides_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn overrides_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, BoneOverride>> {
        (0..self.overrides_len()).map(move |i| self.overrides(i).expect("index below len"))
    }

    pub fn resize_overrides(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2BoneOverrideSet_resize_overrides(self.raw.as_ptr(), count) }
    }
}

impl Default for BoneOverrideSet {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Model {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Model>,
}

impl Drop for Model {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Model_delete(self.raw.as_ptr()) }
    }
}

impl Model {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Model) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Model { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Model {}

impl core::fmt::Debug for Model {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Model").finish_non_exhaustive()
    }
}

impl Model {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Model_new();
            Self::from_raw(raw).expect("native Model allocation failed")
        }
    }

    pub fn model_name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m2_M2Model_get_modelName(self.raw.as_ptr()))
        }
    }

    pub fn set_model_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m2_M2Model_set_modelName(self.raw.as_ptr(), value.as_ptr()) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn global_flags(&self) -> crate::support::Ref<'_, GlobalFlags> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(GlobalFlags {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_globalFlags(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn global_flags_mut(&mut self) -> crate::support::RefMut<'_, GlobalFlags> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(GlobalFlags {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_globalFlags(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn global_loops_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_globalLoops_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn global_loops(&self, index: usize) -> Option<crate::support::Ref<'_, GlobalSequence>> {
        if index >= self.global_loops_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(GlobalSequence {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_globalLoops_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn global_loops_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, GlobalSequence>> {
        if index >= self.global_loops_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(GlobalSequence {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_globalLoops_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn global_loops_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, GlobalSequence>> {
        (0..self.global_loops_len()).map(move |i| self.global_loops(i).expect("index below len"))
    }

    pub fn resize_global_loops(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_globalLoops(self.raw.as_ptr(), count) }
    }

    pub fn sequences_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_sequences_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn sequences(&self, index: usize) -> Option<crate::support::Ref<'_, Sequence>> {
        if index >= self.sequences_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Sequence {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_sequences_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn sequences_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Sequence>> {
        if index >= self.sequences_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Sequence {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_sequences_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn sequences_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Sequence>> {
        (0..self.sequences_len()).map(move |i| self.sequences(i).expect("index below len"))
    }

    pub fn resize_sequences(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_sequences(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn sequence_idx_hash_by_id(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_sequenceIdxHashById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_sequenceIdxHashById_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn sequence_idx_hash_by_id_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_sequenceIdxHashById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_sequenceIdxHashById_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_sequence_idx_hash_by_id(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_sequenceIdxHashById(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_sequence_idx_hash_by_id(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_sequenceIdxHashById(self.raw.as_ptr(), count) }
    }

    pub fn bones_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_bones_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn bones(&self, index: usize) -> Option<crate::support::Ref<'_, Bone>> {
        if index >= self.bones_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Bone {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_bones_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn bones_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Bone>> {
        if index >= self.bones_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Bone {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_bones_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn bones_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Bone>> {
        (0..self.bones_len()).map(move |i| self.bones(i).expect("index below len"))
    }

    pub fn resize_bones(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_bones(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn key_bone_ids(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_keyBoneIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_keyBoneIds_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn key_bone_ids_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_keyBoneIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_keyBoneIds_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_key_bone_ids(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_keyBoneIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_key_bone_ids(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_keyBoneIds(self.raw.as_ptr(), count) }
    }

    pub fn vertices_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_vertices_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn vertices(&self, index: usize) -> Option<crate::support::Ref<'_, Vertex>> {
        if index >= self.vertices_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Vertex {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_vertices_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn vertices_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Vertex>> {
        if index >= self.vertices_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Vertex {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_vertices_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn vertices_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Vertex>> {
        (0..self.vertices_len()).map(move |i| self.vertices(i).expect("index below len"))
    }

    pub fn resize_vertices(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_vertices(self.raw.as_ptr(), count) }
    }

    pub fn skin_profiles_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_skinProfiles_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn skin_profiles(&self, index: usize) -> Option<crate::support::Ref<'_, SkinProfile>> {
        if index >= self.skin_profiles_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SkinProfile {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_skinProfiles_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn skin_profiles_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SkinProfile>> {
        if index >= self.skin_profiles_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SkinProfile {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_skinProfiles_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn skin_profiles_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SkinProfile>> {
        (0..self.skin_profiles_len()).map(move |i| self.skin_profiles(i).expect("index below len"))
    }

    pub fn resize_skin_profiles(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_skinProfiles(self.raw.as_ptr(), count) }
    }

    pub fn lod_profiles_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_lodProfiles_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn lod_profiles(&self, index: usize) -> Option<crate::support::Ref<'_, SkinProfile>> {
        if index >= self.lod_profiles_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SkinProfile {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_lodProfiles_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn lod_profiles_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SkinProfile>> {
        if index >= self.lod_profiles_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SkinProfile {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_lodProfiles_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn lod_profiles_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SkinProfile>> {
        (0..self.lod_profiles_len()).map(move |i| self.lod_profiles(i).expect("index below len"))
    }

    pub fn resize_lod_profiles(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_lodProfiles(self.raw.as_ptr(), count) }
    }

    pub fn num_skin_profiles(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_numSkinProfiles(self.raw.as_ptr()) }
    }

    pub fn set_num_skin_profiles(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_set_numSkinProfiles(self.raw.as_ptr(), value) }
    }

    pub fn colors_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_colors_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn colors(&self, index: usize) -> Option<crate::support::Ref<'_, ColorAnimation>> {
        if index >= self.colors_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ColorAnimation {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_colors_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn colors_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ColorAnimation>> {
        if index >= self.colors_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ColorAnimation {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_colors_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn colors_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ColorAnimation>> {
        (0..self.colors_len()).map(move |i| self.colors(i).expect("index below len"))
    }

    pub fn resize_colors(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_colors(self.raw.as_ptr(), count) }
    }

    pub fn textures_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_textures_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn textures(&self, index: usize) -> Option<crate::support::Ref<'_, Texture>> {
        if index >= self.textures_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Texture {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_textures_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn textures_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Texture>> {
        if index >= self.textures_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Texture {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_textures_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn textures_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Texture>> {
        (0..self.textures_len()).map(move |i| self.textures(i).expect("index below len"))
    }

    pub fn resize_textures(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textures(self.raw.as_ptr(), count) }
    }

    pub fn texture_weights_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_textureWeights_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn texture_weights(&self, index: usize) -> Option<crate::support::Ref<'_, TextureWeight>> {
        if index >= self.texture_weights_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TextureWeight {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_textureWeights_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn texture_weights_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TextureWeight>> {
        if index >= self.texture_weights_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TextureWeight {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_textureWeights_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn texture_weights_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TextureWeight>> {
        (0..self.texture_weights_len())
            .map(move |i| self.texture_weights(i).expect("index below len"))
    }

    pub fn resize_texture_weights(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureWeights(self.raw.as_ptr(), count) }
    }

    pub fn texture_transforms_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_textureTransforms_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn texture_transforms(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, TextureTransform>> {
        if index >= self.texture_transforms_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TextureTransform {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_textureTransforms_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn texture_transforms_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TextureTransform>> {
        if index >= self.texture_transforms_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TextureTransform {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_textureTransforms_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn texture_transforms_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TextureTransform>> {
        (0..self.texture_transforms_len())
            .map(move |i| self.texture_transforms(i).expect("index below len"))
    }

    pub fn resize_texture_transforms(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureTransforms(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_indices_by_id(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureIndicesById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureIndicesById_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_indices_by_id_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureIndicesById_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2Model_get_textureIndicesById_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_indices_by_id(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureIndicesById(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_indices_by_id(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureIndicesById(self.raw.as_ptr(), count) }
    }

    pub fn materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_materials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn materials(&self, index: usize) -> Option<crate::support::Ref<'_, Material>> {
        if index >= self.materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Material {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_materials_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn materials_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Material>> {
        if index >= self.materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Material {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_materials_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Material>> {
        (0..self.materials_len()).map(move |i| self.materials(i).expect("index below len"))
    }

    pub fn resize_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_materials(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn bone_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_boneCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_boneCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn bone_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_boneCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_boneCombos_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_bone_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_boneCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_bone_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_boneCombos(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureCombos_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureCombos(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_coord_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCoordCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureCoordCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_coord_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCoordCombos_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2Model_get_textureCoordCombos_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_coord_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureCoordCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_coord_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureCoordCombos(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_weight_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureWeightCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureWeightCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_weight_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureWeightCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureWeightCombos_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_weight_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureWeightCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_weight_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureWeightCombos(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_transform_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureTransformCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureTransformCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_transform_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureTransformCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureTransformCombos_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_transform_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureTransformCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_transform_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureTransformCombos(self.raw.as_ptr(), count) }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn bounding(&self) -> crate::support::Ref<'_, Extent> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_bounding(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bounding_mut(&mut self) -> crate::support::RefMut<'_, Extent> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_bounding(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Borrows the field in place — no copy, no allocation.
    pub fn collision(&self) -> crate::support::Ref<'_, Extent> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_collision(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn collision_mut(&mut self) -> crate::support::RefMut<'_, Extent> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_collision(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_triangle_indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionTriangleIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionTriangleIndices_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn collision_triangle_indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionTriangleIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionTriangleIndices_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_collision_triangle_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_collisionTriangleIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_triangle_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2Model_resize_collisionTriangleIndices(self.raw.as_ptr(), count)
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_vertices(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionVertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionVertices_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn collision_vertices_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionVertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionVertices_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_collision_vertices(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_collisionVertices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_vertices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_collisionVertices(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_face_normals(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionFaceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionFaceNormals_data(self.raw.as_ptr())
                as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn collision_face_normals_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_collisionFaceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_collisionFaceNormals_data(self.raw.as_ptr())
                as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_collision_face_normals(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_collisionFaceNormals(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_face_normals(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_collisionFaceNormals(self.raw.as_ptr(), count) }
    }

    pub fn attachments_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_attachments_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn attachments(&self, index: usize) -> Option<crate::support::Ref<'_, Attachment>> {
        if index >= self.attachments_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Attachment {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_attachments_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn attachments_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, Attachment>> {
        if index >= self.attachments_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Attachment {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_attachments_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn attachments_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Attachment>> {
        (0..self.attachments_len()).map(move |i| self.attachments(i).expect("index below len"))
    }

    pub fn resize_attachments(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_attachments(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn attachment_indices_by_id(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_attachmentIndicesById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_attachmentIndicesById_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn attachment_indices_by_id_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_attachmentIndicesById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_attachmentIndicesById_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_attachment_indices_by_id(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_attachmentIndicesById(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_attachment_indices_by_id(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_attachmentIndicesById(self.raw.as_ptr(), count) }
    }

    pub fn events_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_events_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn events(&self, index: usize) -> Option<crate::support::Ref<'_, Event>> {
        if index >= self.events_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Event {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_events_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn events_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Event>> {
        if index >= self.events_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Event {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_events_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn events_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Event>> {
        (0..self.events_len()).map(move |i| self.events(i).expect("index below len"))
    }

    pub fn resize_events(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_events(self.raw.as_ptr(), count) }
    }

    pub fn lights_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_lights_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn lights(&self, index: usize) -> Option<crate::support::Ref<'_, Light>> {
        if index >= self.lights_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Light {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_lights_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn lights_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Light>> {
        if index >= self.lights_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Light {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_lights_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn lights_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Light>> {
        (0..self.lights_len()).map(move |i| self.lights(i).expect("index below len"))
    }

    pub fn resize_lights(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_lights(self.raw.as_ptr(), count) }
    }

    pub fn cameras_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_cameras_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn cameras(&self, index: usize) -> Option<crate::support::Ref<'_, Camera>> {
        if index >= self.cameras_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Camera {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_cameras_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn cameras_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Camera>> {
        if index >= self.cameras_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Camera {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_cameras_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn cameras_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Camera>> {
        (0..self.cameras_len()).map(move |i| self.cameras(i).expect("index below len"))
    }

    pub fn resize_cameras(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_cameras(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn camera_indices_by_id(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_cameraIndicesById_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_cameraIndicesById_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn camera_indices_by_id_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_cameraIndicesById_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2Model_get_cameraIndicesById_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_camera_indices_by_id(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_cameraIndicesById(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_camera_indices_by_id(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_cameraIndicesById(self.raw.as_ptr(), count) }
    }

    pub fn ribbon_emitters_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_ribbonEmitters_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn ribbon_emitters(&self, index: usize) -> Option<crate::support::Ref<'_, RibbonEmitter>> {
        if index >= self.ribbon_emitters_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(RibbonEmitter {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_ribbonEmitters_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn ribbon_emitters_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, RibbonEmitter>> {
        if index >= self.ribbon_emitters_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(RibbonEmitter {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_ribbonEmitters_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn ribbon_emitters_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, RibbonEmitter>> {
        (0..self.ribbon_emitters_len())
            .map(move |i| self.ribbon_emitters(i).expect("index below len"))
    }

    pub fn resize_ribbon_emitters(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_ribbonEmitters(self.raw.as_ptr(), count) }
    }

    pub fn particle_emitters_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_particleEmitters_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn particle_emitters(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, ParticleEmitter>> {
        if index >= self.particle_emitters_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ParticleEmitter {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_particleEmitters_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn particle_emitters_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ParticleEmitter>> {
        if index >= self.particle_emitters_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ParticleEmitter {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_particleEmitters_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn particle_emitters_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ParticleEmitter>> {
        (0..self.particle_emitters_len())
            .map(move |i| self.particle_emitters(i).expect("index below len"))
    }

    pub fn resize_particle_emitters(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_particleEmitters(self.raw.as_ptr(), count) }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_combiner_combos(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCombinerCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureCombinerCombos_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_combiner_combos_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureCombinerCombos_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureCombinerCombos_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_combiner_combos(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureCombinerCombos(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_combiner_combos(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureCombinerCombos(self.raw.as_ptr(), count) }
    }

    /// One 4-byte record per animation id; vanilla/BC clients use it to pick fallback animations. Preserved verbatim so old files round-trip.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn playable_animation_lookup(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_playableAnimationLookup_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_playableAnimationLookup_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn playable_animation_lookup_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_playableAnimationLookup_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_playableAnimationLookup_data(self.raw.as_ptr())
                as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_playable_animation_lookup(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_playableAnimationLookup(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_playable_animation_lookup(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_playableAnimationLookup(self.raw.as_ptr(), count) }
    }

    /// "Texture flipbooks" — unused even by old clients, preserved verbatim.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_flipbooks(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureFlipbooks_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_textureFlipbooks_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_flipbooks_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_textureFlipbooks_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2Model_get_textureFlipbooks_data(self.raw.as_ptr()) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_flipbooks(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_textureFlipbooks(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_flipbooks(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_textureFlipbooks(self.raw.as_ptr(), count) }
    }

    /// TXID
    /// Zero-copy view of the underlying `std::vector`.
    pub fn texture_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_texture_ids_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_texture_ids_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn texture_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_texture_ids_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_texture_ids_data(self.raw.as_ptr()) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_texture_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_texture_ids(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_texture_ids(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_texture_ids(self.raw.as_ptr(), count) }
    }

    /// PABC
    /// Zero-copy view of the underlying `std::vector`.
    pub fn parent_sequence_replacements(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m2_M2Model_get_parentSequenceReplacements_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_parentSequenceReplacements_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn parent_sequence_replacements_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m2_M2Model_get_parentSequenceReplacements_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_parentSequenceReplacements_data(self.raw.as_ptr())
                as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_parent_sequence_replacements(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_parentSequenceReplacements(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_parent_sequence_replacements(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2Model_resize_parentSequenceReplacements(self.raw.as_ptr(), count)
        }
    }

    /// PADC
    pub fn parent_texture_weights_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_parentTextureWeights_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn parent_texture_weights(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, TextureWeight>> {
        if index >= self.parent_texture_weights_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TextureWeight {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentTextureWeights_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn parent_texture_weights_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TextureWeight>> {
        if index >= self.parent_texture_weights_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TextureWeight {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentTextureWeights_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn parent_texture_weights_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TextureWeight>> {
        (0..self.parent_texture_weights_len())
            .map(move |i| self.parent_texture_weights(i).expect("index below len"))
    }

    pub fn resize_parent_texture_weights(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_parentTextureWeights(self.raw.as_ptr(), count) }
    }

    /// PSBC
    pub fn parent_sequence_bounds_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_parentSequenceBounds_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn parent_sequence_bounds(&self, index: usize) -> Option<crate::support::Ref<'_, Extent>> {
        if index >= self.parent_sequence_bounds_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentSequenceBounds_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn parent_sequence_bounds_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, Extent>> {
        if index >= self.parent_sequence_bounds_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Extent {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentSequenceBounds_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn parent_sequence_bounds_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Extent>> {
        (0..self.parent_sequence_bounds_len())
            .map(move |i| self.parent_sequence_bounds(i).expect("index below len"))
    }

    pub fn resize_parent_sequence_bounds(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_parentSequenceBounds(self.raw.as_ptr(), count) }
    }

    /// PEDC
    pub fn parent_event_data_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_parentEventData_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn parent_event_data(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, AnimationTrackBase>> {
        if index >= self.parent_event_data_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(AnimationTrackBase {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentEventData_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn parent_event_data_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, AnimationTrackBase>> {
        if index >= self.parent_event_data_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(AnimationTrackBase {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_parentEventData_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn parent_event_data_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, AnimationTrackBase>> {
        (0..self.parent_event_data_len())
            .map(move |i| self.parent_event_data(i).expect("index below len"))
    }

    pub fn resize_parent_event_data(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_parentEventData(self.raw.as_ptr(), count) }
    }

    /// RPID
    /// Zero-copy view of the underlying `std::vector`.
    pub fn recursive_particle_model_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_recursiveParticleModelIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_recursiveParticleModelIds_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn recursive_particle_model_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_recursiveParticleModelIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_recursiveParticleModelIds_data(self.raw.as_ptr())
                as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_recursive_particle_model_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_recursiveParticleModelIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_recursive_particle_model_ids(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2Model_resize_recursiveParticleModelIds(self.raw.as_ptr(), count)
        }
    }

    /// GPID
    /// Zero-copy view of the underlying `std::vector`.
    pub fn geometry_particle_model_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_geometryParticleModelIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_geometryParticleModelIds_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn geometry_particle_model_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_geometryParticleModelIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_geometryParticleModelIds_data(self.raw.as_ptr())
                as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_geometry_particle_model_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_geometryParticleModelIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_geometry_particle_model_ids(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2Model_resize_geometryParticleModelIds(self.raw.as_ptr(), count)
        }
    }

    /// PGD1
    pub fn particle_geosets_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_particleGeosets_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn particle_geosets(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, ParticleGeosetData>> {
        if index >= self.particle_geosets_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ParticleGeosetData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_particleGeosets_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn particle_geosets_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ParticleGeosetData>> {
        if index >= self.particle_geosets_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ParticleGeosetData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_particleGeosets_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn particle_geosets_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ParticleGeosetData>> {
        (0..self.particle_geosets_len())
            .map(move |i| self.particle_geosets(i).expect("index below len"))
    }

    pub fn resize_particle_geosets(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_particleGeosets(self.raw.as_ptr(), count) }
    }

    /// One entry per customization choice, in BFID order — see bone_file.h.
    pub fn bone_overrides_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_boneOverrides_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn bone_overrides(&self, index: usize) -> Option<crate::support::Ref<'_, BoneOverrideSet>> {
        if index >= self.bone_overrides_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(BoneOverrideSet {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_boneOverrides_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn bone_overrides_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, BoneOverrideSet>> {
        if index >= self.bone_overrides_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(BoneOverrideSet {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_boneOverrides_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn bone_overrides_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, BoneOverrideSet>> {
        (0..self.bone_overrides_len())
            .map(move |i| self.bone_overrides(i).expect("index below len"))
    }

    pub fn resize_bone_overrides(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_boneOverrides(self.raw.as_ptr(), count) }
    }

    /// BFID, kept so a model that named its `.bone` files by id keeps doing so. Parallel to @ref boneOverrides when both are present.
    /// Zero-copy view of the underlying `std::vector`.
    pub fn bone_file_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_boneFileIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_boneFileIds_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn bone_file_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_boneFileIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_boneFileIds_data(self.raw.as_ptr()) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_bone_file_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_boneFileIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_bone_file_ids(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_boneFileIds(self.raw.as_ptr(), count) }
    }

    /// EDGF
    pub fn edge_fade_entries_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_edgeFadeEntries_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn edge_fade_entries(&self, index: usize) -> Option<crate::support::Ref<'_, EdgeFadeData>> {
        if index >= self.edge_fade_entries_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(EdgeFadeData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_edgeFadeEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn edge_fade_entries_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, EdgeFadeData>> {
        if index >= self.edge_fade_entries_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(EdgeFadeData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_edgeFadeEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn edge_fade_entries_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, EdgeFadeData>> {
        (0..self.edge_fade_entries_len())
            .map(move |i| self.edge_fade_entries(i).expect("index below len"))
    }

    pub fn resize_edge_fade_entries(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_edgeFadeEntries(self.raw.as_ptr(), count) }
    }

    /// NERF
    pub fn nerf_entries_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_nerfEntries_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn nerf_entries(&self, index: usize) -> Option<crate::support::Ref<'_, DistanceFadeData>> {
        if index >= self.nerf_entries_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DistanceFadeData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_nerfEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn nerf_entries_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DistanceFadeData>> {
        if index >= self.nerf_entries_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DistanceFadeData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_nerfEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn nerf_entries_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DistanceFadeData>> {
        (0..self.nerf_entries_len()).map(move |i| self.nerf_entries(i).expect("index below len"))
    }

    pub fn resize_nerf_entries(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_nerfEntries(self.raw.as_ptr(), count) }
    }

    /// DETL
    pub fn detailed_light_entries_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_detailedLightEntries_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn detailed_light_entries(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, DetailedLightData>> {
        if index >= self.detailed_light_entries_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DetailedLightData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_detailedLightEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn detailed_light_entries_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DetailedLightData>> {
        if index >= self.detailed_light_entries_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DetailedLightData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_detailedLightEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn detailed_light_entries_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DetailedLightData>> {
        (0..self.detailed_light_entries_len())
            .map(move |i| self.detailed_light_entries(i).expect("index below len"))
    }

    pub fn resize_detailed_light_entries(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_detailedLightEntries(self.raw.as_ptr(), count) }
    }

    /// DBOC
    pub fn debug_occlusion_entries_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_debugOcclusionEntries_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn debug_occlusion_entries(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, DebugOcclusionData>> {
        if index >= self.debug_occlusion_entries_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DebugOcclusionData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_debugOcclusionEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn debug_occlusion_entries_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DebugOcclusionData>> {
        if index >= self.debug_occlusion_entries_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DebugOcclusionData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_debugOcclusionEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn debug_occlusion_entries_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DebugOcclusionData>> {
        (0..self.debug_occlusion_entries_len())
            .map(move |i| self.debug_occlusion_entries(i).expect("index below len"))
    }

    pub fn resize_debug_occlusion_entries(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_debugOcclusionEntries(self.raw.as_ptr(), count) }
    }

    /// AFRA
    /// Zero-copy view of the underlying `std::vector`.
    pub fn anim_frame_data(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_animFrameData_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_animFrameData_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn anim_frame_data_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2Model_get_animFrameData_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2Model_get_animFrameData_data(self.raw.as_ptr()) as *mut u8;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_anim_frame_data(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2Model_assign_animFrameData(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_anim_frame_data(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_animFrameData(self.raw.as_ptr(), count) }
    }

    /// DPIV (32 B per record)
    pub fn dpiv_data_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_dpivData_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn dpiv_data(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, PivotDisplacementData>> {
        if index >= self.dpiv_data_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PivotDisplacementData {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_dpivData_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn dpiv_data_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PivotDisplacementData>> {
        if index >= self.dpiv_data_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PivotDisplacementData {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m2_M2Model_get_dpivData_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn dpiv_data_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PivotDisplacementData>> {
        (0..self.dpiv_data_len()).map(move |i| self.dpiv_data(i).expect("index below len"))
    }

    pub fn resize_dpiv_data(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_dpivData(self.raw.as_ptr(), count) }
    }

    /// TEXL
    pub fn textured_light_entries_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2Model_get_texturedLightEntries_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn textured_light_entries(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, TexturedLightData>> {
        if index >= self.textured_light_entries_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TexturedLightData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_texturedLightEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn textured_light_entries_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TexturedLightData>> {
        if index >= self.textured_light_entries_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TexturedLightData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2Model_get_texturedLightEntries_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn textured_light_entries_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TexturedLightData>> {
        (0..self.textured_light_entries_len())
            .map(move |i| self.textured_light_entries(i).expect("index below len"))
    }

    pub fn resize_textured_light_entries(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2Model_resize_texturedLightEntries(self.raw.as_ptr(), count) }
    }
}

impl Default for Model {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Parser {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Parser>,
}

impl Drop for Parser {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Parser_delete(self.raw.as_ptr()) }
    }
}

impl Parser {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Parser) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Parser { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Parser {}

impl core::fmt::Debug for Parser {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Parser").finish_non_exhaustive()
    }
}

impl Parser {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Parser_new();
            Self::from_raw(raw).expect("native Parser allocation failed")
        }
    }

    pub fn parse_file(
        &mut self,
        fs: Option<&crate::interfaces::HostFileSystem>,
        file_path: &str,
    ) -> Option<Model> {
        let file_path_cstr = std::ffi::CString::new(file_path).unwrap_or_default();
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            Model::from_raw(ffi::whiteout_m2_M2Parser_parse(
                self.raw.as_ptr(),
                fs.map_or(core::ptr::null_mut(), |v| v.as_ptr()),
                file_path_cstr.as_ptr(),
            ))
        }
    }

    pub fn parse_casc_fs_buffer(&mut self, casc_fs: &[u8], buffer: &[u8]) -> Option<Model> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            Model::from_raw(ffi::whiteout_m2_M2Parser_parse_cascFs_buffer(
                self.raw.as_ptr(),
                casc_fs.as_ptr(),
                casc_fs.len(),
                buffer.as_ptr(),
                buffer.len(),
            ))
        }
    }

    /// Leave the keys of sequences stored in `.anim` siblings unread until m2::loadSequence() asks for them. Off by default.
    ///
    /// This is what the client does — nothing reads a `.anim` until something plays that sequence — and on a character model with a hundred of them it is the difference between a load that reads one file and one that reads a hundred. See sequence_loader.h.
    ///
    /// The @p fs passed to parse() has to outlive the returned Model, because the deferred reads go back through it.
    pub fn set_lazy_animations(&mut self, enable: bool) {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            ffi::whiteout_m2_M2Parser_setLazyAnimations(
                self.raw.as_ptr(),
                if enable { 1 } else { 0 },
            );
        }
    }

    pub fn has_issues(&self) -> bool {
        // SAFETY: handle is live for the duration of the call.
        unsafe { ffi::whiteout_m2_M2Parser_hasIssues(self.raw.as_ptr()) != 0 }
    }

    pub fn issues(&self) -> Vec<String> {
        // SAFETY: index stays below the reported count.
        unsafe {
            let n = ffi::whiteout_m2_M2Parser_getIssues_count(self.raw.as_ptr());
            (0..n)
                .map(|i| {
                    crate::support::take_string(ffi::whiteout_m2_M2Parser_getIssues_at(
                        self.raw.as_ptr(),
                        i,
                    ))
                })
                .collect()
        }
    }
}

impl Default for Parser {
    fn default() -> Self {
        Self::new()
    }
}

pub struct WriteOptions {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2WriteOptions>,
}

impl Drop for WriteOptions {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2WriteOptions_delete(self.raw.as_ptr()) }
    }
}

impl WriteOptions {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2WriteOptions) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| WriteOptions { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for WriteOptions {}

impl core::fmt::Debug for WriteOptions {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("WriteOptions").finish_non_exhaustive()
    }
}

impl WriteOptions {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2WriteOptions_new();
            Self::from_raw(raw).expect("native WriteOptions allocation failed")
        }
    }

    pub fn m_2_version(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WriteOptions_get_m2Version(self.raw.as_ptr()) }
    }

    pub fn set_m_2_version(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m2_M2WriteOptions_set_m2Version(self.raw.as_ptr(), value) }
    }

    pub fn emit_skeleton(&self) -> bool {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2WriteOptions_get_emitSkeleton(self.raw.as_ptr()) != 0 }
    }

    pub fn set_emit_skeleton(&mut self, value: bool) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2WriteOptions_set_emitSkeleton(
                self.raw.as_ptr(),
                if value { 1 } else { 0 },
            )
        }
    }

    pub fn base_stem(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m2_M2WriteOptions_get_baseStem(
                self.raw.as_ptr(),
            ))
        }
    }

    pub fn set_base_stem(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m2_M2WriteOptions_set_baseStem(self.raw.as_ptr(), value.as_ptr()) }
    }
}

impl Default for WriteOptions {
    fn default() -> Self {
        Self::new()
    }
}

pub struct SerializeResult {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2SerializeResult>,
}

impl Drop for SerializeResult {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2SerializeResult_delete(self.raw.as_ptr()) }
    }
}

impl SerializeResult {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2SerializeResult) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SerializeResult { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for SerializeResult {}

impl core::fmt::Debug for SerializeResult {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("SerializeResult").finish_non_exhaustive()
    }
}

impl SerializeResult {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2SerializeResult_new();
            Self::from_raw(raw).expect("native SerializeResult allocation failed")
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn m_2_data(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2SerializeResult_get_m2Data_count(self.raw.as_ptr());
            let p = ffi::whiteout_m2_M2SerializeResult_get_m2Data_data(self.raw.as_ptr());
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn m_2_data_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2SerializeResult_get_m2Data_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m2_M2SerializeResult_get_m2Data_data(self.raw.as_ptr()) as *mut u8;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_m_2_data(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2SerializeResult_assign_m2Data(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_m_2_data(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2SerializeResult_resize_m2Data(self.raw.as_ptr(), count) }
    }
}

impl Default for SerializeResult {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Writer {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2Writer>,
}

impl Drop for Writer {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2Writer_delete(self.raw.as_ptr()) }
    }
}

impl Writer {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2Writer) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Writer { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for Writer {}

impl core::fmt::Debug for Writer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Writer").finish_non_exhaustive()
    }
}

impl Writer {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2Writer_new();
            Self::from_raw(raw).expect("native Writer allocation failed")
        }
    }

    pub fn write_file(
        &mut self,
        fs: Option<&crate::interfaces::HostFileSystem>,
        file_path: &str,
        model: &Model,
    ) {
        let file_path_cstr = std::ffi::CString::new(file_path).unwrap_or_default();
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            ffi::whiteout_m2_M2Writer_write(
                self.raw.as_ptr(),
                fs.map_or(core::ptr::null_mut(), |v| v.as_ptr()),
                file_path_cstr.as_ptr(),
                model.raw.as_ptr(),
            );
        }
    }

    pub fn write_casc_fs_model(
        &mut self,
        casc_fs: Option<&crate::interfaces::HostCascFileSystem>,
        model: &Model,
    ) {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            ffi::whiteout_m2_M2Writer_write_cascFs_model(
                self.raw.as_ptr(),
                casc_fs.map_or(core::ptr::null_mut(), |v| v.as_ptr()),
                model.raw.as_ptr(),
            );
        }
    }

    pub fn write(&mut self, model: &Model) -> Option<SerializeResult> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            SerializeResult::from_raw(ffi::whiteout_m2_M2Writer_write_model(
                self.raw.as_ptr(),
                model.raw.as_ptr(),
            ))
        }
    }

    pub fn has_issues(&self) -> bool {
        // SAFETY: handle is live for the duration of the call.
        unsafe { ffi::whiteout_m2_M2Writer_hasIssues(self.raw.as_ptr()) != 0 }
    }

    pub fn issues(&self) -> Vec<String> {
        // SAFETY: index stays below the reported count.
        unsafe {
            let n = ffi::whiteout_m2_M2Writer_getIssues_count(self.raw.as_ptr());
            (0..n)
                .map(|i| {
                    crate::support::take_string(ffi::whiteout_m2_M2Writer_getIssues_at(
                        self.raw.as_ptr(),
                        i,
                    ))
                })
                .collect()
        }
    }
}

impl Default for Writer {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackVector3f {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackVector3f>,
}

impl Drop for AnimationTrackVector3f {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackVector3f_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackVector3f {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2AnimationTrackVector3f,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackVector3f { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackVector3f {}

impl core::fmt::Debug for AnimationTrackVector3f {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackVector3f")
            .finish_non_exhaustive()
    }
}

impl AnimationTrackVector3f {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackVector3f_new();
            Self::from_raw(raw).expect("native AnimationTrackVector3f allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_get_interpolationType(self.raw.as_ptr())
        }
        .try_into()
        .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackVector3f_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackVector3f_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_resize_timestamps(self.raw.as_ptr(), count)
        }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackVector3f_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[crate::math::Vector3f] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackVector3f_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackVector3f_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [crate::math::Vector3f] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackVector3f_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackVector3f_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackVector3f_resize_values(self.raw.as_ptr(), count) }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackVector3f_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackVector3f {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackM2CompatQuaternion {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackM2CompatQuaternion>,
}

impl Drop for AnimationTrackM2CompatQuaternion {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackM2CompatQuaternion {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2AnimationTrackM2CompatQuaternion,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackM2CompatQuaternion { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackM2CompatQuaternion {}

impl core::fmt::Debug for AnimationTrackM2CompatQuaternion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackM2CompatQuaternion")
            .finish_non_exhaustive()
    }
}

impl AnimationTrackM2CompatQuaternion {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_new();
            Self::from_raw(raw).expect("native AnimationTrackM2CompatQuaternion allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_interpolationType(
                self.raw.as_ptr(),
            )
        }
        .try_into()
        .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_globalSequenceId(
                self.raw.as_ptr(),
            )
        }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_globalSequenceId(
                self.raw.as_ptr(),
                value,
            )
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_count(
                self.raw.as_ptr(),
            )
        }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps(
                self.raw.as_ptr(),
                count,
            )
        }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_count(self.raw.as_ptr())
        }
    }

    /// Length of inner sequence `outer`.
    pub fn values_inner_len(&self, outer: usize) -> usize {
        if outer >= self.values_len() {
            return 0;
        }
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            )
        }
    }

    /// Borrow element `inner` of sequence `outer` in place.
    pub fn values(
        &self,
        outer: usize,
        inner: usize,
    ) -> Option<crate::support::Ref<'_, CompatQuaternion>> {
        if inner >= self.values_inner_len(outer) {
            return None;
        }
        // SAFETY: both indices checked; the pointer is
        // interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(CompatQuaternion {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_at(
                        self.raw.as_ptr(),
                        outer,
                        inner,
                    ),
                ),
            }))
        }
    }

    pub fn values_mut(
        &mut self,
        outer: usize,
        inner: usize,
    ) -> Option<crate::support::RefMut<'_, CompatQuaternion>> {
        if inner >= self.values_inner_len(outer) {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(CompatQuaternion {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_at(
                        self.raw.as_ptr(),
                        outer,
                        inner,
                    ),
                ),
            }))
        }
    }

    /// Resize the outer sequence. Do this before taking a borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values(
                self.raw.as_ptr(),
                count,
            )
        }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackM2CompatQuaternion {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackI16 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackI16>,
}

impl Drop for AnimationTrackI16 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackI16 {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2AnimationTrackI16) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackI16 { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackI16 {}

impl core::fmt::Debug for AnimationTrackI16 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackI16").finish_non_exhaustive()
    }
}

impl AnimationTrackI16 {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackI16_new();
            Self::from_raw(raw).expect("native AnimationTrackI16 allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_get_interpolationType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_resize_timestamps(self.raw.as_ptr(), count) }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[i16] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackI16_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackI16_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [i16] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackI16_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackI16_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut i16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[i16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackI16_resize_values(self.raw.as_ptr(), count) }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackI16_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackI16 {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackQuaternion {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackQuaternion>,
}

impl Drop for AnimationTrackQuaternion {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackQuaternion_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackQuaternion {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2AnimationTrackQuaternion,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackQuaternion { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackQuaternion {}

impl core::fmt::Debug for AnimationTrackQuaternion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackQuaternion")
            .finish_non_exhaustive()
    }
}

impl AnimationTrackQuaternion {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackQuaternion_new();
            Self::from_raw(raw).expect("native AnimationTrackQuaternion allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_get_interpolationType(self.raw.as_ptr())
        }
        .try_into()
        .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_get_globalSequenceId(self.raw.as_ptr())
        }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_set_globalSequenceId(
                self.raw.as_ptr(),
                value,
            )
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_count(self.raw.as_ptr())
        }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_resize_timestamps(self.raw.as_ptr(), count)
        }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackQuaternion_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[crate::math::Quaternion] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *const crate::math::Quaternion;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [crate::math::Quaternion] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *const crate::math::Quaternion as *mut crate::math::Quaternion;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[crate::math::Quaternion]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_resize_values(self.raw.as_ptr(), count)
        }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackQuaternion_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackQuaternion {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackF32 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackF32>,
}

impl Drop for AnimationTrackF32 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackF32 {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2AnimationTrackF32) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackF32 { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackF32 {}

impl core::fmt::Debug for AnimationTrackF32 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackF32").finish_non_exhaustive()
    }
}

impl AnimationTrackF32 {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackF32_new();
            Self::from_raw(raw).expect("native AnimationTrackF32 allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_get_interpolationType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_resize_timestamps(self.raw.as_ptr(), count) }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[f32] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackF32_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackF32_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [f32] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackF32_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackF32_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut f32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[f32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackF32_resize_values(self.raw.as_ptr(), count) }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackF32_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackF32 {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackU8 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackU8>,
}

impl Drop for AnimationTrackU8 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackU8 {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2AnimationTrackU8) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackU8 { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackU8 {}

impl core::fmt::Debug for AnimationTrackU8 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackU8").finish_non_exhaustive()
    }
}

impl AnimationTrackU8 {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackU8_new();
            Self::from_raw(raw).expect("native AnimationTrackU8 allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_get_interpolationType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_resize_timestamps(self.raw.as_ptr(), count) }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[u8] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU8_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p =
                ffi::whiteout_m2_M2AnimationTrackU8_get_values_inner_data(self.raw.as_ptr(), outer);
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [u8] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU8_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p =
                ffi::whiteout_m2_M2AnimationTrackU8_get_values_inner_data(self.raw.as_ptr(), outer)
                    as *mut u8;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU8_resize_values(self.raw.as_ptr(), count) }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU8_resize_values_inner(self.raw.as_ptr(), outer, count)
        }
    }
}

impl Default for AnimationTrackU8 {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackM2CameraSpline {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackM2CameraSpline>,
}

impl Drop for AnimationTrackM2CameraSpline {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackM2CameraSpline {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2AnimationTrackM2CameraSpline,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackM2CameraSpline { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackM2CameraSpline {}

impl core::fmt::Debug for AnimationTrackM2CameraSpline {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackM2CameraSpline")
            .finish_non_exhaustive()
    }
}

impl AnimationTrackM2CameraSpline {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_new();
            Self::from_raw(raw).expect("native AnimationTrackM2CameraSpline allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_interpolationType(self.raw.as_ptr())
        }
        .try_into()
        .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_globalSequenceId(self.raw.as_ptr())
        }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_set_globalSequenceId(
                self.raw.as_ptr(),
                value,
            )
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_count(self.raw.as_ptr())
        }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps(
                self.raw.as_ptr(),
                count,
            )
        }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_count(self.raw.as_ptr())
        }
    }

    /// Length of inner sequence `outer`.
    pub fn values_inner_len(&self, outer: usize) -> usize {
        if outer >= self.values_len() {
            return 0;
        }
        // SAFETY: index checked above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            )
        }
    }

    /// Borrow element `inner` of sequence `outer` in place.
    pub fn values(
        &self,
        outer: usize,
        inner: usize,
    ) -> Option<crate::support::Ref<'_, CameraSpline>> {
        if inner >= self.values_inner_len(outer) {
            return None;
        }
        // SAFETY: both indices checked; the pointer is
        // interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_at(
                        self.raw.as_ptr(),
                        outer,
                        inner,
                    ),
                ),
            }))
        }
    }

    pub fn values_mut(
        &mut self,
        outer: usize,
        inner: usize,
    ) -> Option<crate::support::RefMut<'_, CameraSpline>> {
        if inner >= self.values_inner_len(outer) {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(CameraSpline {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_at(
                        self.raw.as_ptr(),
                        outer,
                        inner,
                    ),
                ),
            }))
        }
    }

    /// Resize the outer sequence. Do this before taking a borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values(self.raw.as_ptr(), count)
        }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackM2CameraSpline {
    fn default() -> Self {
        Self::new()
    }
}

/// instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline
pub struct AnimationTrackU16 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2AnimationTrackU16>,
}

impl Drop for AnimationTrackU16 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_delete(self.raw.as_ptr()) }
    }
}

impl AnimationTrackU16 {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(raw: *mut ffi::whiteout_M2AnimationTrackU16) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationTrackU16 { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for AnimationTrackU16 {}

impl core::fmt::Debug for AnimationTrackU16 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimationTrackU16").finish_non_exhaustive()
    }
}

impl AnimationTrackU16 {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2AnimationTrackU16_new();
            Self::from_raw(raw).expect("native AnimationTrackU16 allocation failed")
        }
    }

    pub fn interpolation_type(&self) -> InterpolationType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_get_interpolationType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_interpolation_type(&mut self, value: InterpolationType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_set_interpolationType(
                self.raw.as_ptr(),
                value as i32,
            )
        }
    }

    pub fn global_sequence_id(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_get_globalSequenceId(self.raw.as_ptr()) }
    }

    pub fn set_global_sequence_id(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_set_globalSequenceId(self.raw.as_ptr(), value)
        }
    }

    /// Number of inner sequences.
    pub fn timestamps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_get_timestamps_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn timestamps(&self, outer: usize) -> &[u32] {
        if outer >= self.timestamps_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn timestamps_mut(&mut self, outer: usize) -> &mut [u32] {
        if outer >= self.timestamps_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u32;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_timestamps(&mut self, outer: usize, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_assign_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_timestamps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_resize_timestamps(self.raw.as_ptr(), count) }
    }

    pub fn resize_timestamps_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_resize_timestamps_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }

    /// Number of inner sequences.
    pub fn values_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_get_values_count(self.raw.as_ptr()) }
    }

    /// Zero-copy view of inner sequence `outer`. Empty when out of range.
    ///
    /// Each inner vector is contiguous on its own, but the outer one
    /// is a vector of vectors — so this borrows per sequence rather
    /// than handing back one flat slice.
    pub fn values(&self, outer: usize) -> &[u16] {
        if outer >= self.values_len() {
            return &[];
        }
        // SAFETY: index checked; the pointer borrows `self`.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU16_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU16_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            );
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    pub fn values_mut(&mut self, outer: usize) -> &mut [u16] {
        if outer >= self.values_len() {
            return &mut [];
        }
        // SAFETY: as above; `&mut self` rules out aliasing.
        unsafe {
            let n = ffi::whiteout_m2_M2AnimationTrackU16_get_values_inner_count(
                self.raw.as_ptr(),
                outer,
            );
            let p = ffi::whiteout_m2_M2AnimationTrackU16_get_values_inner_data(
                self.raw.as_ptr(),
                outer,
            ) as *mut u16;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, outer: usize, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_assign_values_inner(
                self.raw.as_ptr(),
                outer,
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    /// Resize the outer sequence. Do this before taking any borrow.
    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m2_M2AnimationTrackU16_resize_values(self.raw.as_ptr(), count) }
    }

    pub fn resize_values_inner(&mut self, outer: usize, count: usize) {
        // SAFETY: as above.
        unsafe {
            ffi::whiteout_m2_M2AnimationTrackU16_resize_values_inner(
                self.raw.as_ptr(),
                outer,
                count,
            )
        }
    }
}

impl Default for AnimationTrackU16 {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ParticleAnimationTrackVector3f {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ParticleAnimationTrackVector3f>,
}

impl Drop for ParticleAnimationTrackVector3f {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_delete(self.raw.as_ptr()) }
    }
}

impl ParticleAnimationTrackVector3f {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2ParticleAnimationTrackVector3f,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleAnimationTrackVector3f { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ParticleAnimationTrackVector3f {}

impl core::fmt::Debug for ParticleAnimationTrackVector3f {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ParticleAnimationTrackVector3f")
            .finish_non_exhaustive()
    }
}

impl ParticleAnimationTrackVector3f {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_new();
            Self::from_raw(raw).expect("native ParticleAnimationTrackVector3f allocation failed")
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn values(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_count(
                self.raw.as_ptr(),
            );
            let p = ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_data(
                self.raw.as_ptr(),
            ) as *const crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn values_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_count(
                self.raw.as_ptr(),
            );
            let p = ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_data(
                self.raw.as_ptr(),
            ) as *const crate::math::Vector3f as *mut crate::math::Vector3f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_assign_values(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2ParticleAnimationTrackVector3f_resize_values(
                self.raw.as_ptr(),
                count,
            )
        }
    }
}

impl Default for ParticleAnimationTrackVector3f {
    fn default() -> Self {
        Self::new()
    }
}

pub struct ParticleAnimationTrackVector2f {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M2ParticleAnimationTrackVector2f>,
}

impl Drop for ParticleAnimationTrackVector2f {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_delete(self.raw.as_ptr()) }
    }
}

impl ParticleAnimationTrackVector2f {
    /// # Safety
    /// `raw` must be a live handle this value takes ownership of.
    #[allow(dead_code)] // used by whichever methods return this type
    pub(crate) unsafe fn from_raw(
        raw: *mut ffi::whiteout_M2ParticleAnimationTrackVector2f,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleAnimationTrackVector2f { raw })
    }
}

// SAFETY: handles are plain heap pointers with no thread affinity. `Sync`
// is deliberately NOT implemented — the C++ types make no documented
// guarantee about concurrent use, and claiming one we haven't verified
// would be unsound. See `@bind thread_safe` in the plan.
unsafe impl Send for ParticleAnimationTrackVector2f {}

impl core::fmt::Debug for ParticleAnimationTrackVector2f {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ParticleAnimationTrackVector2f")
            .finish_non_exhaustive()
    }
}

impl ParticleAnimationTrackVector2f {
    /// # Panics
    /// Panics if the native allocation fails.
    pub fn new() -> Self {
        // SAFETY: the native constructor returns a live handle; a null here
        // means the library is unusable.
        unsafe {
            let raw = ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_new();
            Self::from_raw(raw).expect("native ParticleAnimationTrackVector2f allocation failed")
        }
    }

    /// Zero-copy view of the underlying `std::vector`.
    pub fn values(&self) -> &[crate::math::Vector2f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_count(
                self.raw.as_ptr(),
            );
            let p = ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_data(
                self.raw.as_ptr(),
            ) as *const crate::math::Vector2f;
            if p.is_null() || n == 0 {
                &[]
            } else {
                core::slice::from_raw_parts(p, n)
            }
        }
    }

    /// Zero-copy mutable view. Resize first — the borrow forbids it after.
    pub fn values_mut(&mut self) -> &mut [crate::math::Vector2f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_count(
                self.raw.as_ptr(),
            );
            let p = ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_data(
                self.raw.as_ptr(),
            ) as *const crate::math::Vector2f as *mut crate::math::Vector2f;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_values(&mut self, values: &[crate::math::Vector2f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_assign_values(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_values(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m2_M2ParticleAnimationTrackVector2f_resize_values(
                self.raw.as_ptr(),
                count,
            )
        }
    }
}

impl Default for ParticleAnimationTrackVector2f {
    fn default() -> Self {
        Self::new()
    }
}

#[doc(hidden)]
pub mod ffi {
    #![allow(missing_debug_implementations)]

    #[allow(unused_imports)]
    use crate::support::{RawBytes, RawCString};

    #[repr(C)]
    pub struct whiteout_M2CompatQuaternion {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ColorBGRA {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Extent {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2KeySpanRef {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackBase {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ParticleEmitterExtension {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2LodProfile {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2WaterfallData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ParticleGeosetData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2EdgeFadeData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2DistanceFadeData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2DetailedLightData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2DebugOcclusionData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2TexturedLightData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PivotDisplacementData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsCollision {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2SkinSection {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Batch {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ShadowBatch {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2SkinProfile {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2GlobalFlags {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2GlobalSequence {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Sequence {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Vertex {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Bone {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Texture {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Material {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2TextureWeight {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2TextureTransform {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ColorAnimation {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Light {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2CameraSpline {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Camera {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Attachment {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2RibbonEmitter {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Box {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ParticleEmitter {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Event {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsFrame {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsBody {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2BoxShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2CapsuleShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2SphereShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PolytopeHalfEdge {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PolytopeShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2WeldJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2SphericalJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ShoulderJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PrismaticJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2RevoluteJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2DistanceJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsTuning {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsUnknownChunk {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2PhysicsData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2BoneOverride {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2BoneOverrideSet {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Model {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Parser {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2WriteOptions {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2SerializeResult {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2Writer {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackVector3f {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackM2CompatQuaternion {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackI16 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackQuaternion {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackF32 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackU8 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackM2CameraSpline {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2AnimationTrackU16 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ParticleAnimationTrackVector3f {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M2ParticleAnimationTrackVector2f {
        _private: [u8; 0],
    }

    extern "C" {
        // CompatQuaternion
        pub fn whiteout_m2_M2CompatQuaternion_new() -> *mut whiteout_M2CompatQuaternion;
        pub fn whiteout_m2_M2CompatQuaternion_delete(self_: *mut whiteout_M2CompatQuaternion);
        // ColorBGRA
        pub fn whiteout_m2_M2ColorBGRA_new() -> *mut whiteout_M2ColorBGRA;
        pub fn whiteout_m2_M2ColorBGRA_delete(self_: *mut whiteout_M2ColorBGRA);
        // Extent
        pub fn whiteout_m2_M2Extent_new() -> *mut whiteout_M2Extent;
        pub fn whiteout_m2_M2Extent_delete(self_: *mut whiteout_M2Extent);
        pub fn whiteout_m2_M2Extent_get_minimum(
            self_: *mut whiteout_M2Extent,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Extent_set_minimum(
            self_: *mut whiteout_M2Extent,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Extent_get_maximum(
            self_: *mut whiteout_M2Extent,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Extent_set_maximum(
            self_: *mut whiteout_M2Extent,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Extent_get_sphereRadius(self_: *mut whiteout_M2Extent) -> f32;
        pub fn whiteout_m2_M2Extent_set_sphereRadius(self_: *mut whiteout_M2Extent, value: f32);
        // KeySpanRef
        pub fn whiteout_m2_M2KeySpanRef_new() -> *mut whiteout_M2KeySpanRef;
        pub fn whiteout_m2_M2KeySpanRef_delete(self_: *mut whiteout_M2KeySpanRef);
        pub fn whiteout_m2_M2KeySpanRef_get_count(self_: *mut whiteout_M2KeySpanRef) -> u32;
        pub fn whiteout_m2_M2KeySpanRef_set_count(self_: *mut whiteout_M2KeySpanRef, value: u32);
        pub fn whiteout_m2_M2KeySpanRef_get_offset(self_: *mut whiteout_M2KeySpanRef) -> u32;
        pub fn whiteout_m2_M2KeySpanRef_set_offset(self_: *mut whiteout_M2KeySpanRef, value: u32);
        // AnimationTrackBase
        pub fn whiteout_m2_M2AnimationTrackBase_new() -> *mut whiteout_M2AnimationTrackBase;
        pub fn whiteout_m2_M2AnimationTrackBase_delete(self_: *mut whiteout_M2AnimationTrackBase);
        pub fn whiteout_m2_M2AnimationTrackBase_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackBase,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackBase_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackBase,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackBase_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackBase,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackBase_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackBase,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackBase_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackBase,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackBase,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackBase_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackBase,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackBase_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackBase,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackBase,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackBase_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackBase,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        // ParticleEmitterExtension
        pub fn whiteout_m2_M2ParticleEmitterExtension_new(
        ) -> *mut whiteout_M2ParticleEmitterExtension;
        pub fn whiteout_m2_M2ParticleEmitterExtension_delete(
            self_: *mut whiteout_M2ParticleEmitterExtension,
        );
        pub fn whiteout_m2_M2ParticleEmitterExtension_get_zSource(
            self_: *mut whiteout_M2ParticleEmitterExtension,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitterExtension_set_zSource(
            self_: *mut whiteout_M2ParticleEmitterExtension,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitterExtension_get_colorMult(
            self_: *mut whiteout_M2ParticleEmitterExtension,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitterExtension_set_colorMult(
            self_: *mut whiteout_M2ParticleEmitterExtension,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitterExtension_get_alphaMult(
            self_: *mut whiteout_M2ParticleEmitterExtension,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitterExtension_set_alphaMult(
            self_: *mut whiteout_M2ParticleEmitterExtension,
            value: f32,
        );
        // LodProfile
        pub fn whiteout_m2_M2LodProfile_new() -> *mut whiteout_M2LodProfile;
        pub fn whiteout_m2_M2LodProfile_delete(self_: *mut whiteout_M2LodProfile);
        pub fn whiteout_m2_M2LodProfile_get_flags(self_: *mut whiteout_M2LodProfile) -> u16;
        pub fn whiteout_m2_M2LodProfile_set_flags(self_: *mut whiteout_M2LodProfile, value: u16);
        pub fn whiteout_m2_M2LodProfile_get_numLodLevels(self_: *mut whiteout_M2LodProfile) -> u16;
        pub fn whiteout_m2_M2LodProfile_set_numLodLevels(
            self_: *mut whiteout_M2LodProfile,
            value: u16,
        );
        pub fn whiteout_m2_M2LodProfile_get_lodDistance(self_: *mut whiteout_M2LodProfile) -> f32;
        pub fn whiteout_m2_M2LodProfile_set_lodDistance(
            self_: *mut whiteout_M2LodProfile,
            value: f32,
        );
        pub fn whiteout_m2_M2LodProfile_particleBoneLod_size() -> usize;
        pub fn whiteout_m2_M2LodProfile_get_particleBoneLod_at(
            self_: *mut whiteout_M2LodProfile,
            index: usize,
        ) -> u8;
        pub fn whiteout_m2_M2LodProfile_set_particleBoneLod_at(
            self_: *mut whiteout_M2LodProfile,
            index: usize,
            value: u8,
        );
        pub fn whiteout_m2_M2LodProfile_get_lodScaleRaw(self_: *mut whiteout_M2LodProfile) -> u16;
        pub fn whiteout_m2_M2LodProfile_set_lodScaleRaw(
            self_: *mut whiteout_M2LodProfile,
            value: u16,
        );
        pub fn whiteout_m2_M2LodProfile_get_lodBatchCount(self_: *mut whiteout_M2LodProfile) -> u8;
        pub fn whiteout_m2_M2LodProfile_set_lodBatchCount(
            self_: *mut whiteout_M2LodProfile,
            value: u8,
        );
        pub fn whiteout_m2_M2LodProfile_get_reserved1(self_: *mut whiteout_M2LodProfile) -> u8;
        pub fn whiteout_m2_M2LodProfile_set_reserved1(self_: *mut whiteout_M2LodProfile, value: u8);
        // WaterfallData
        pub fn whiteout_m2_M2WaterfallData_new() -> *mut whiteout_M2WaterfallData;
        pub fn whiteout_m2_M2WaterfallData_delete(self_: *mut whiteout_M2WaterfallData);
        pub fn whiteout_m2_M2WaterfallData_get_bumpScale(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_bumpScale(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value0_x(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value0_x(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value0_y(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value0_y(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value0_z(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value0_z(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value1_w(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value1_w(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value0_w(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value0_w(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value1_x(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value1_x(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value1_y(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value1_y(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value2_w(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value2_w(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value3_y(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value3_y(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value3_x(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value3_x(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_baseColor(
            self_: *mut whiteout_M2WaterfallData,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2WaterfallData_set_baseColor(
            self_: *mut whiteout_M2WaterfallData,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2WaterfallData_get_flags(self_: *mut whiteout_M2WaterfallData) -> u16;
        pub fn whiteout_m2_M2WaterfallData_set_flags(
            self_: *mut whiteout_M2WaterfallData,
            value: u16,
        );
        pub fn whiteout_m2_M2WaterfallData_get_unknown0(
            self_: *mut whiteout_M2WaterfallData,
        ) -> u16;
        pub fn whiteout_m2_M2WaterfallData_set_unknown0(
            self_: *mut whiteout_M2WaterfallData,
            value: u16,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value3_w(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value3_w(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value3_z(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value3_z(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_value4_y(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_value4_y(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_unknown1(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_unknown1(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_unknown2(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_unknown2(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_unknown3(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_unknown3(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        pub fn whiteout_m2_M2WaterfallData_get_unknown4(
            self_: *mut whiteout_M2WaterfallData,
        ) -> f32;
        pub fn whiteout_m2_M2WaterfallData_set_unknown4(
            self_: *mut whiteout_M2WaterfallData,
            value: f32,
        );
        // ParticleGeosetData
        pub fn whiteout_m2_M2ParticleGeosetData_new() -> *mut whiteout_M2ParticleGeosetData;
        pub fn whiteout_m2_M2ParticleGeosetData_delete(self_: *mut whiteout_M2ParticleGeosetData);
        pub fn whiteout_m2_M2ParticleGeosetData_get_geoset(
            self_: *mut whiteout_M2ParticleGeosetData,
        ) -> u16;
        pub fn whiteout_m2_M2ParticleGeosetData_set_geoset(
            self_: *mut whiteout_M2ParticleGeosetData,
            value: u16,
        );
        // EdgeFadeData
        pub fn whiteout_m2_M2EdgeFadeData_new() -> *mut whiteout_M2EdgeFadeData;
        pub fn whiteout_m2_M2EdgeFadeData_delete(self_: *mut whiteout_M2EdgeFadeData);
        pub fn whiteout_m2_M2EdgeFadeData_value0_size() -> usize;
        pub fn whiteout_m2_M2EdgeFadeData_get_value0_at(
            self_: *mut whiteout_M2EdgeFadeData,
            index: usize,
        ) -> f32;
        pub fn whiteout_m2_M2EdgeFadeData_set_value0_at(
            self_: *mut whiteout_M2EdgeFadeData,
            index: usize,
            value: f32,
        );
        pub fn whiteout_m2_M2EdgeFadeData_get_value8(self_: *mut whiteout_M2EdgeFadeData) -> f32;
        pub fn whiteout_m2_M2EdgeFadeData_set_value8(
            self_: *mut whiteout_M2EdgeFadeData,
            value: f32,
        );
        pub fn whiteout_m2_M2EdgeFadeData_valueC_size() -> usize;
        pub fn whiteout_m2_M2EdgeFadeData_get_valueC_at(
            self_: *mut whiteout_M2EdgeFadeData,
            index: usize,
        ) -> u8;
        pub fn whiteout_m2_M2EdgeFadeData_set_valueC_at(
            self_: *mut whiteout_M2EdgeFadeData,
            index: usize,
            value: u8,
        );
        // DistanceFadeData
        pub fn whiteout_m2_M2DistanceFadeData_new() -> *mut whiteout_M2DistanceFadeData;
        pub fn whiteout_m2_M2DistanceFadeData_delete(self_: *mut whiteout_M2DistanceFadeData);
        pub fn whiteout_m2_M2DistanceFadeData_get_squaredFarDist(
            self_: *mut whiteout_M2DistanceFadeData,
        ) -> f32;
        pub fn whiteout_m2_M2DistanceFadeData_set_squaredFarDist(
            self_: *mut whiteout_M2DistanceFadeData,
            value: f32,
        );
        pub fn whiteout_m2_M2DistanceFadeData_get_squaredNearDist(
            self_: *mut whiteout_M2DistanceFadeData,
        ) -> f32;
        pub fn whiteout_m2_M2DistanceFadeData_set_squaredNearDist(
            self_: *mut whiteout_M2DistanceFadeData,
            value: f32,
        );
        pub fn whiteout_m2_M2DistanceFadeData_reserved_size() -> usize;
        pub fn whiteout_m2_M2DistanceFadeData_get_reserved_at(
            self_: *mut whiteout_M2DistanceFadeData,
            index: usize,
        ) -> u32;
        pub fn whiteout_m2_M2DistanceFadeData_set_reserved_at(
            self_: *mut whiteout_M2DistanceFadeData,
            index: usize,
            value: u32,
        );
        // DetailedLightData
        pub fn whiteout_m2_M2DetailedLightData_new() -> *mut whiteout_M2DetailedLightData;
        pub fn whiteout_m2_M2DetailedLightData_delete(self_: *mut whiteout_M2DetailedLightData);
        pub fn whiteout_m2_M2DetailedLightData_get_flags(
            self_: *mut whiteout_M2DetailedLightData,
        ) -> u16;
        pub fn whiteout_m2_M2DetailedLightData_set_flags(
            self_: *mut whiteout_M2DetailedLightData,
            value: u16,
        );
        pub fn whiteout_m2_M2DetailedLightData_get_unknown0(
            self_: *mut whiteout_M2DetailedLightData,
        ) -> u16;
        pub fn whiteout_m2_M2DetailedLightData_set_unknown0(
            self_: *mut whiteout_M2DetailedLightData,
            value: u16,
        );
        pub fn whiteout_m2_M2DetailedLightData_get_unknown1(
            self_: *mut whiteout_M2DetailedLightData,
        ) -> u32;
        pub fn whiteout_m2_M2DetailedLightData_set_unknown1(
            self_: *mut whiteout_M2DetailedLightData,
            value: u32,
        );
        // DebugOcclusionData
        pub fn whiteout_m2_M2DebugOcclusionData_new() -> *mut whiteout_M2DebugOcclusionData;
        pub fn whiteout_m2_M2DebugOcclusionData_delete(self_: *mut whiteout_M2DebugOcclusionData);
        pub fn whiteout_m2_M2DebugOcclusionData_get_unknown1_1(
            self_: *mut whiteout_M2DebugOcclusionData,
        ) -> f32;
        pub fn whiteout_m2_M2DebugOcclusionData_set_unknown1_1(
            self_: *mut whiteout_M2DebugOcclusionData,
            value: f32,
        );
        pub fn whiteout_m2_M2DebugOcclusionData_get_unknown1_2(
            self_: *mut whiteout_M2DebugOcclusionData,
        ) -> f32;
        pub fn whiteout_m2_M2DebugOcclusionData_set_unknown1_2(
            self_: *mut whiteout_M2DebugOcclusionData,
            value: f32,
        );
        pub fn whiteout_m2_M2DebugOcclusionData_get_unknown1_3(
            self_: *mut whiteout_M2DebugOcclusionData,
        ) -> u32;
        pub fn whiteout_m2_M2DebugOcclusionData_set_unknown1_3(
            self_: *mut whiteout_M2DebugOcclusionData,
            value: u32,
        );
        pub fn whiteout_m2_M2DebugOcclusionData_get_unknown1_4(
            self_: *mut whiteout_M2DebugOcclusionData,
        ) -> u32;
        pub fn whiteout_m2_M2DebugOcclusionData_set_unknown1_4(
            self_: *mut whiteout_M2DebugOcclusionData,
            value: u32,
        );
        // TexturedLightData
        pub fn whiteout_m2_M2TexturedLightData_new() -> *mut whiteout_M2TexturedLightData;
        pub fn whiteout_m2_M2TexturedLightData_delete(self_: *mut whiteout_M2TexturedLightData);
        pub fn whiteout_m2_M2TexturedLightData_get_unknown0(
            self_: *mut whiteout_M2TexturedLightData,
        ) -> f32;
        pub fn whiteout_m2_M2TexturedLightData_set_unknown0(
            self_: *mut whiteout_M2TexturedLightData,
            value: f32,
        );
        pub fn whiteout_m2_M2TexturedLightData_get_unknown1(
            self_: *mut whiteout_M2TexturedLightData,
        ) -> f32;
        pub fn whiteout_m2_M2TexturedLightData_set_unknown1(
            self_: *mut whiteout_M2TexturedLightData,
            value: f32,
        );
        pub fn whiteout_m2_M2TexturedLightData_get_textureLookup(
            self_: *mut whiteout_M2TexturedLightData,
        ) -> i32;
        pub fn whiteout_m2_M2TexturedLightData_set_textureLookup(
            self_: *mut whiteout_M2TexturedLightData,
            value: i32,
        );
        pub fn whiteout_m2_M2TexturedLightData_get_unknown2(
            self_: *mut whiteout_M2TexturedLightData,
        ) -> i32;
        pub fn whiteout_m2_M2TexturedLightData_set_unknown2(
            self_: *mut whiteout_M2TexturedLightData,
            value: i32,
        );
        // PivotDisplacementData
        pub fn whiteout_m2_M2PivotDisplacementData_new() -> *mut whiteout_M2PivotDisplacementData;
        pub fn whiteout_m2_M2PivotDisplacementData_delete(
            self_: *mut whiteout_M2PivotDisplacementData,
        );
        pub fn whiteout_m2_M2PivotDisplacementData_get_offset(
            self_: *mut whiteout_M2PivotDisplacementData,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PivotDisplacementData_set_offset(
            self_: *mut whiteout_M2PivotDisplacementData,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PivotDisplacementData_get_flags(
            self_: *mut whiteout_M2PivotDisplacementData,
        ) -> u32;
        pub fn whiteout_m2_M2PivotDisplacementData_set_flags(
            self_: *mut whiteout_M2PivotDisplacementData,
            value: u32,
        );
        pub fn whiteout_m2_M2PivotDisplacementData_reserved_size() -> usize;
        pub fn whiteout_m2_M2PivotDisplacementData_get_reserved_at(
            self_: *mut whiteout_M2PivotDisplacementData,
            index: usize,
        ) -> u32;
        pub fn whiteout_m2_M2PivotDisplacementData_set_reserved_at(
            self_: *mut whiteout_M2PivotDisplacementData,
            index: usize,
            value: u32,
        );
        // PhysicsCollision
        pub fn whiteout_m2_M2PhysicsCollision_new() -> *mut whiteout_M2PhysicsCollision;
        pub fn whiteout_m2_M2PhysicsCollision_delete(self_: *mut whiteout_M2PhysicsCollision);
        pub fn whiteout_m2_M2PhysicsCollision_get_vertexPositions_count(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsCollision_resize_vertexPositions(
            self_: *mut whiteout_M2PhysicsCollision,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_vertexPositions_data(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> *const f32;
        pub fn whiteout_m2_M2PhysicsCollision_assign_vertexPositions(
            self_: *mut whiteout_M2PhysicsCollision,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_faceNormals_count(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsCollision_resize_faceNormals(
            self_: *mut whiteout_M2PhysicsCollision,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_faceNormals_data(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> *const f32;
        pub fn whiteout_m2_M2PhysicsCollision_assign_faceNormals(
            self_: *mut whiteout_M2PhysicsCollision,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_indices_count(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsCollision_resize_indices(
            self_: *mut whiteout_M2PhysicsCollision,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_indices_data(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> *const i16;
        pub fn whiteout_m2_M2PhysicsCollision_assign_indices(
            self_: *mut whiteout_M2PhysicsCollision,
            data: *const i16,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_flags_count(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsCollision_resize_flags(
            self_: *mut whiteout_M2PhysicsCollision,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsCollision_get_flags_data(
            self_: *mut whiteout_M2PhysicsCollision,
        ) -> *const i16;
        pub fn whiteout_m2_M2PhysicsCollision_assign_flags(
            self_: *mut whiteout_M2PhysicsCollision,
            data: *const i16,
            count: usize,
        );
        // SkinSection
        pub fn whiteout_m2_M2SkinSection_new() -> *mut whiteout_M2SkinSection;
        pub fn whiteout_m2_M2SkinSection_delete(self_: *mut whiteout_M2SkinSection);
        pub fn whiteout_m2_M2SkinSection_get_skinSectionId(
            self_: *mut whiteout_M2SkinSection,
        ) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_skinSectionId(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_level(self_: *mut whiteout_M2SkinSection) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_level(self_: *mut whiteout_M2SkinSection, value: u16);
        pub fn whiteout_m2_M2SkinSection_get_vertexStart(self_: *mut whiteout_M2SkinSection)
            -> u16;
        pub fn whiteout_m2_M2SkinSection_set_vertexStart(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_vertexCount(self_: *mut whiteout_M2SkinSection)
            -> u16;
        pub fn whiteout_m2_M2SkinSection_set_vertexCount(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_indexStart(self_: *mut whiteout_M2SkinSection) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_indexStart(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_indexCount(self_: *mut whiteout_M2SkinSection) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_indexCount(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_boneCount(self_: *mut whiteout_M2SkinSection) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_boneCount(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_boneComboIndex(
            self_: *mut whiteout_M2SkinSection,
        ) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_boneComboIndex(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_boneInfluences(
            self_: *mut whiteout_M2SkinSection,
        ) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_boneInfluences(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_centerBoneIndex(
            self_: *mut whiteout_M2SkinSection,
        ) -> u16;
        pub fn whiteout_m2_M2SkinSection_set_centerBoneIndex(
            self_: *mut whiteout_M2SkinSection,
            value: u16,
        );
        pub fn whiteout_m2_M2SkinSection_get_centerPosition(
            self_: *mut whiteout_M2SkinSection,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2SkinSection_set_centerPosition(
            self_: *mut whiteout_M2SkinSection,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2SkinSection_get_sortCenterPosition(
            self_: *mut whiteout_M2SkinSection,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2SkinSection_set_sortCenterPosition(
            self_: *mut whiteout_M2SkinSection,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2SkinSection_get_sortRadius(self_: *mut whiteout_M2SkinSection) -> f32;
        pub fn whiteout_m2_M2SkinSection_set_sortRadius(
            self_: *mut whiteout_M2SkinSection,
            value: f32,
        );
        // Batch
        pub fn whiteout_m2_M2Batch_new() -> *mut whiteout_M2Batch;
        pub fn whiteout_m2_M2Batch_delete(self_: *mut whiteout_M2Batch);
        pub fn whiteout_m2_M2Batch_get_flags(self_: *mut whiteout_M2Batch) -> u8;
        pub fn whiteout_m2_M2Batch_set_flags(self_: *mut whiteout_M2Batch, value: u8);
        pub fn whiteout_m2_M2Batch_get_priorityPlane(self_: *mut whiteout_M2Batch) -> i8;
        pub fn whiteout_m2_M2Batch_set_priorityPlane(self_: *mut whiteout_M2Batch, value: i8);
        pub fn whiteout_m2_M2Batch_get_shaderId(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_shaderId(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_skinSectionIndex(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_skinSectionIndex(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_geosetIndex(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_geosetIndex(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_colorIndex(self_: *mut whiteout_M2Batch) -> i16;
        pub fn whiteout_m2_M2Batch_set_colorIndex(self_: *mut whiteout_M2Batch, value: i16);
        pub fn whiteout_m2_M2Batch_get_materialIndex(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_materialIndex(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_materialLayer(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_materialLayer(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_textureCount(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_textureCount(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_textureComboIndex(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_textureComboIndex(self_: *mut whiteout_M2Batch, value: u16);
        pub fn whiteout_m2_M2Batch_get_textureCoordComboIndex(self_: *mut whiteout_M2Batch) -> u16;
        pub fn whiteout_m2_M2Batch_set_textureCoordComboIndex(
            self_: *mut whiteout_M2Batch,
            value: u16,
        );
        pub fn whiteout_m2_M2Batch_get_textureWeightComboIndex(self_: *mut whiteout_M2Batch)
            -> u16;
        pub fn whiteout_m2_M2Batch_set_textureWeightComboIndex(
            self_: *mut whiteout_M2Batch,
            value: u16,
        );
        pub fn whiteout_m2_M2Batch_get_textureTransformComboIndex(
            self_: *mut whiteout_M2Batch,
        ) -> u16;
        pub fn whiteout_m2_M2Batch_set_textureTransformComboIndex(
            self_: *mut whiteout_M2Batch,
            value: u16,
        );
        // ShadowBatch
        pub fn whiteout_m2_M2ShadowBatch_new() -> *mut whiteout_M2ShadowBatch;
        pub fn whiteout_m2_M2ShadowBatch_delete(self_: *mut whiteout_M2ShadowBatch);
        pub fn whiteout_m2_M2ShadowBatch_get_flags(self_: *mut whiteout_M2ShadowBatch) -> u8;
        pub fn whiteout_m2_M2ShadowBatch_set_flags(self_: *mut whiteout_M2ShadowBatch, value: u8);
        pub fn whiteout_m2_M2ShadowBatch_get_flags2(self_: *mut whiteout_M2ShadowBatch) -> u8;
        pub fn whiteout_m2_M2ShadowBatch_set_flags2(self_: *mut whiteout_M2ShadowBatch, value: u8);
        pub fn whiteout_m2_M2ShadowBatch_get_unknown0(self_: *mut whiteout_M2ShadowBatch) -> u16;
        pub fn whiteout_m2_M2ShadowBatch_set_unknown0(
            self_: *mut whiteout_M2ShadowBatch,
            value: u16,
        );
        pub fn whiteout_m2_M2ShadowBatch_get_submeshId(self_: *mut whiteout_M2ShadowBatch) -> u16;
        pub fn whiteout_m2_M2ShadowBatch_set_submeshId(
            self_: *mut whiteout_M2ShadowBatch,
            value: u16,
        );
        pub fn whiteout_m2_M2ShadowBatch_get_textureId(self_: *mut whiteout_M2ShadowBatch) -> u16;
        pub fn whiteout_m2_M2ShadowBatch_set_textureId(
            self_: *mut whiteout_M2ShadowBatch,
            value: u16,
        );
        pub fn whiteout_m2_M2ShadowBatch_get_colorId(self_: *mut whiteout_M2ShadowBatch) -> u16;
        pub fn whiteout_m2_M2ShadowBatch_set_colorId(
            self_: *mut whiteout_M2ShadowBatch,
            value: u16,
        );
        pub fn whiteout_m2_M2ShadowBatch_get_transparencyId(
            self_: *mut whiteout_M2ShadowBatch,
        ) -> u16;
        pub fn whiteout_m2_M2ShadowBatch_set_transparencyId(
            self_: *mut whiteout_M2ShadowBatch,
            value: u16,
        );
        // SkinProfile
        pub fn whiteout_m2_M2SkinProfile_new() -> *mut whiteout_M2SkinProfile;
        pub fn whiteout_m2_M2SkinProfile_delete(self_: *mut whiteout_M2SkinProfile);
        pub fn whiteout_m2_M2SkinProfile_get_vertices_count(
            self_: *mut whiteout_M2SkinProfile,
        ) -> usize;
        pub fn whiteout_m2_M2SkinProfile_resize_vertices(
            self_: *mut whiteout_M2SkinProfile,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_vertices_data(
            self_: *mut whiteout_M2SkinProfile,
        ) -> *const u16;
        pub fn whiteout_m2_M2SkinProfile_assign_vertices(
            self_: *mut whiteout_M2SkinProfile,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_indices_count(
            self_: *mut whiteout_M2SkinProfile,
        ) -> usize;
        pub fn whiteout_m2_M2SkinProfile_resize_indices(
            self_: *mut whiteout_M2SkinProfile,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_indices_data(
            self_: *mut whiteout_M2SkinProfile,
        ) -> *const u16;
        pub fn whiteout_m2_M2SkinProfile_assign_indices(
            self_: *mut whiteout_M2SkinProfile,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_submeshes_count(
            self_: *mut whiteout_M2SkinProfile,
        ) -> usize;
        pub fn whiteout_m2_M2SkinProfile_resize_submeshes(
            self_: *mut whiteout_M2SkinProfile,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_submeshes_at(
            self_: *mut whiteout_M2SkinProfile,
            index: usize,
        ) -> *mut whiteout_M2SkinSection;
        pub fn whiteout_m2_M2SkinProfile_get_batches_count(
            self_: *mut whiteout_M2SkinProfile,
        ) -> usize;
        pub fn whiteout_m2_M2SkinProfile_resize_batches(
            self_: *mut whiteout_M2SkinProfile,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_batches_at(
            self_: *mut whiteout_M2SkinProfile,
            index: usize,
        ) -> *mut whiteout_M2Batch;
        pub fn whiteout_m2_M2SkinProfile_get_lodVertexBase(
            self_: *mut whiteout_M2SkinProfile,
        ) -> u32;
        pub fn whiteout_m2_M2SkinProfile_set_lodVertexBase(
            self_: *mut whiteout_M2SkinProfile,
            value: u32,
        );
        pub fn whiteout_m2_M2SkinProfile_get_shadowBatches_count(
            self_: *mut whiteout_M2SkinProfile,
        ) -> usize;
        pub fn whiteout_m2_M2SkinProfile_resize_shadowBatches(
            self_: *mut whiteout_M2SkinProfile,
            count: usize,
        );
        pub fn whiteout_m2_M2SkinProfile_get_shadowBatches_at(
            self_: *mut whiteout_M2SkinProfile,
            index: usize,
        ) -> *mut whiteout_M2ShadowBatch;
        // GlobalFlags
        pub fn whiteout_m2_M2GlobalFlags_new() -> *mut whiteout_M2GlobalFlags;
        pub fn whiteout_m2_M2GlobalFlags_delete(self_: *mut whiteout_M2GlobalFlags);
        pub fn whiteout_m2_M2GlobalFlags_get_value(self_: *mut whiteout_M2GlobalFlags) -> i32;
        pub fn whiteout_m2_M2GlobalFlags_set_value(self_: *mut whiteout_M2GlobalFlags, value: i32);
        // GlobalSequence
        pub fn whiteout_m2_M2GlobalSequence_new() -> *mut whiteout_M2GlobalSequence;
        pub fn whiteout_m2_M2GlobalSequence_delete(self_: *mut whiteout_M2GlobalSequence);
        pub fn whiteout_m2_M2GlobalSequence_get_timestamp(
            self_: *mut whiteout_M2GlobalSequence,
        ) -> u32;
        pub fn whiteout_m2_M2GlobalSequence_set_timestamp(
            self_: *mut whiteout_M2GlobalSequence,
            value: u32,
        );
        // Sequence
        pub fn whiteout_m2_M2Sequence_new() -> *mut whiteout_M2Sequence;
        pub fn whiteout_m2_M2Sequence_delete(self_: *mut whiteout_M2Sequence);
        pub fn whiteout_m2_M2Sequence_get_id(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_id(self_: *mut whiteout_M2Sequence, value: u16);
        pub fn whiteout_m2_M2Sequence_get_variationIndex(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_variationIndex(
            self_: *mut whiteout_M2Sequence,
            value: u16,
        );
        pub fn whiteout_m2_M2Sequence_get_duration(self_: *mut whiteout_M2Sequence) -> u32;
        pub fn whiteout_m2_M2Sequence_set_duration(self_: *mut whiteout_M2Sequence, value: u32);
        pub fn whiteout_m2_M2Sequence_get_movespeed(self_: *mut whiteout_M2Sequence) -> f32;
        pub fn whiteout_m2_M2Sequence_set_movespeed(self_: *mut whiteout_M2Sequence, value: f32);
        pub fn whiteout_m2_M2Sequence_get_flags(self_: *mut whiteout_M2Sequence) -> i32;
        pub fn whiteout_m2_M2Sequence_set_flags(self_: *mut whiteout_M2Sequence, value: i32);
        pub fn whiteout_m2_M2Sequence_get_frequency(self_: *mut whiteout_M2Sequence) -> i16;
        pub fn whiteout_m2_M2Sequence_set_frequency(self_: *mut whiteout_M2Sequence, value: i16);
        pub fn whiteout_m2_M2Sequence_get_padding(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_padding(self_: *mut whiteout_M2Sequence, value: u16);
        pub fn whiteout_m2_M2Sequence_get_replayMin(self_: *mut whiteout_M2Sequence) -> u32;
        pub fn whiteout_m2_M2Sequence_set_replayMin(self_: *mut whiteout_M2Sequence, value: u32);
        pub fn whiteout_m2_M2Sequence_get_replayMax(self_: *mut whiteout_M2Sequence) -> u32;
        pub fn whiteout_m2_M2Sequence_set_replayMax(self_: *mut whiteout_M2Sequence, value: u32);
        pub fn whiteout_m2_M2Sequence_get_blendTimeIn(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_blendTimeIn(self_: *mut whiteout_M2Sequence, value: u16);
        pub fn whiteout_m2_M2Sequence_get_blendTimeOut(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_blendTimeOut(self_: *mut whiteout_M2Sequence, value: u16);
        pub fn whiteout_m2_M2Sequence_get_bounding(
            self_: *mut whiteout_M2Sequence,
        ) -> *mut whiteout_M2Extent;
        pub fn whiteout_m2_M2Sequence_set_bounding(
            self_: *mut whiteout_M2Sequence,
            value: *const whiteout_M2Extent,
        );
        pub fn whiteout_m2_M2Sequence_get_variationNext(self_: *mut whiteout_M2Sequence) -> i16;
        pub fn whiteout_m2_M2Sequence_set_variationNext(
            self_: *mut whiteout_M2Sequence,
            value: i16,
        );
        pub fn whiteout_m2_M2Sequence_get_aliasNext(self_: *mut whiteout_M2Sequence) -> u16;
        pub fn whiteout_m2_M2Sequence_set_aliasNext(self_: *mut whiteout_M2Sequence, value: u16);
        // Vertex
        pub fn whiteout_m2_M2Vertex_new() -> *mut whiteout_M2Vertex;
        pub fn whiteout_m2_M2Vertex_delete(self_: *mut whiteout_M2Vertex);
        pub fn whiteout_m2_M2Vertex_get_position(
            self_: *mut whiteout_M2Vertex,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Vertex_set_position(
            self_: *mut whiteout_M2Vertex,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Vertex_boneWeights_size() -> usize;
        pub fn whiteout_m2_M2Vertex_get_boneWeights_at(
            self_: *mut whiteout_M2Vertex,
            index: usize,
        ) -> u8;
        pub fn whiteout_m2_M2Vertex_set_boneWeights_at(
            self_: *mut whiteout_M2Vertex,
            index: usize,
            value: u8,
        );
        pub fn whiteout_m2_M2Vertex_boneIndices_size() -> usize;
        pub fn whiteout_m2_M2Vertex_get_boneIndices_at(
            self_: *mut whiteout_M2Vertex,
            index: usize,
        ) -> u8;
        pub fn whiteout_m2_M2Vertex_set_boneIndices_at(
            self_: *mut whiteout_M2Vertex,
            index: usize,
            value: u8,
        );
        pub fn whiteout_m2_M2Vertex_get_normal(
            self_: *mut whiteout_M2Vertex,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Vertex_set_normal(
            self_: *mut whiteout_M2Vertex,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Vertex_texCoords_size() -> usize;
        pub fn whiteout_m2_M2Vertex_get_texCoords_at(
            self_: *mut whiteout_M2Vertex,
            index: usize,
        ) -> *mut core::ffi::c_void;
        // Bone
        pub fn whiteout_m2_M2Bone_new() -> *mut whiteout_M2Bone;
        pub fn whiteout_m2_M2Bone_delete(self_: *mut whiteout_M2Bone);
        pub fn whiteout_m2_M2Bone_get_keyBoneId(self_: *mut whiteout_M2Bone) -> i32;
        pub fn whiteout_m2_M2Bone_set_keyBoneId(self_: *mut whiteout_M2Bone, value: i32);
        pub fn whiteout_m2_M2Bone_get_flags(self_: *mut whiteout_M2Bone) -> u32;
        pub fn whiteout_m2_M2Bone_set_flags(self_: *mut whiteout_M2Bone, value: u32);
        pub fn whiteout_m2_M2Bone_get_parentBoneId(self_: *mut whiteout_M2Bone) -> i16;
        pub fn whiteout_m2_M2Bone_set_parentBoneId(self_: *mut whiteout_M2Bone, value: i16);
        pub fn whiteout_m2_M2Bone_get_submeshId(self_: *mut whiteout_M2Bone) -> u16;
        pub fn whiteout_m2_M2Bone_set_submeshId(self_: *mut whiteout_M2Bone, value: u16);
        pub fn whiteout_m2_M2Bone_get_boneNameCRC(self_: *mut whiteout_M2Bone) -> u32;
        pub fn whiteout_m2_M2Bone_set_boneNameCRC(self_: *mut whiteout_M2Bone, value: u32);
        pub fn whiteout_m2_M2Bone_get_translation(
            self_: *mut whiteout_M2Bone,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2Bone_set_translation(
            self_: *mut whiteout_M2Bone,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2Bone_get_rotation(
            self_: *mut whiteout_M2Bone,
        ) -> *mut whiteout_M2AnimationTrackM2CompatQuaternion;
        pub fn whiteout_m2_M2Bone_set_rotation(
            self_: *mut whiteout_M2Bone,
            value: *const whiteout_M2AnimationTrackM2CompatQuaternion,
        );
        pub fn whiteout_m2_M2Bone_get_scale(
            self_: *mut whiteout_M2Bone,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2Bone_set_scale(
            self_: *mut whiteout_M2Bone,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2Bone_get_pivot(self_: *mut whiteout_M2Bone) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Bone_set_pivot(
            self_: *mut whiteout_M2Bone,
            value: *const core::ffi::c_void,
        );
        // Texture
        pub fn whiteout_m2_M2Texture_new() -> *mut whiteout_M2Texture;
        pub fn whiteout_m2_M2Texture_delete(self_: *mut whiteout_M2Texture);
        pub fn whiteout_m2_M2Texture_get_type(self_: *mut whiteout_M2Texture) -> u32;
        pub fn whiteout_m2_M2Texture_set_type(self_: *mut whiteout_M2Texture, value: u32);
        pub fn whiteout_m2_M2Texture_get_flags(self_: *mut whiteout_M2Texture) -> u32;
        pub fn whiteout_m2_M2Texture_set_flags(self_: *mut whiteout_M2Texture, value: u32);
        pub fn whiteout_m2_M2Texture_get_filename(self_: *mut whiteout_M2Texture) -> RawCString;
        pub fn whiteout_m2_M2Texture_set_filename(
            self_: *mut whiteout_M2Texture,
            value: *const core::ffi::c_char,
        );
        // Material
        pub fn whiteout_m2_M2Material_new() -> *mut whiteout_M2Material;
        pub fn whiteout_m2_M2Material_delete(self_: *mut whiteout_M2Material);
        pub fn whiteout_m2_M2Material_get_flags(self_: *mut whiteout_M2Material) -> u16;
        pub fn whiteout_m2_M2Material_set_flags(self_: *mut whiteout_M2Material, value: u16);
        pub fn whiteout_m2_M2Material_get_blendingMode(self_: *mut whiteout_M2Material) -> u16;
        pub fn whiteout_m2_M2Material_set_blendingMode(self_: *mut whiteout_M2Material, value: u16);
        // TextureWeight
        pub fn whiteout_m2_M2TextureWeight_new() -> *mut whiteout_M2TextureWeight;
        pub fn whiteout_m2_M2TextureWeight_delete(self_: *mut whiteout_M2TextureWeight);
        pub fn whiteout_m2_M2TextureWeight_get_weight(
            self_: *mut whiteout_M2TextureWeight,
        ) -> *mut whiteout_M2AnimationTrackI16;
        pub fn whiteout_m2_M2TextureWeight_set_weight(
            self_: *mut whiteout_M2TextureWeight,
            value: *const whiteout_M2AnimationTrackI16,
        );
        // TextureTransform
        pub fn whiteout_m2_M2TextureTransform_new() -> *mut whiteout_M2TextureTransform;
        pub fn whiteout_m2_M2TextureTransform_delete(self_: *mut whiteout_M2TextureTransform);
        pub fn whiteout_m2_M2TextureTransform_get_translation(
            self_: *mut whiteout_M2TextureTransform,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2TextureTransform_set_translation(
            self_: *mut whiteout_M2TextureTransform,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2TextureTransform_get_rotation(
            self_: *mut whiteout_M2TextureTransform,
        ) -> *mut whiteout_M2AnimationTrackQuaternion;
        pub fn whiteout_m2_M2TextureTransform_set_rotation(
            self_: *mut whiteout_M2TextureTransform,
            value: *const whiteout_M2AnimationTrackQuaternion,
        );
        pub fn whiteout_m2_M2TextureTransform_get_scaling(
            self_: *mut whiteout_M2TextureTransform,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2TextureTransform_set_scaling(
            self_: *mut whiteout_M2TextureTransform,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        // ColorAnimation
        pub fn whiteout_m2_M2ColorAnimation_new() -> *mut whiteout_M2ColorAnimation;
        pub fn whiteout_m2_M2ColorAnimation_delete(self_: *mut whiteout_M2ColorAnimation);
        pub fn whiteout_m2_M2ColorAnimation_get_color(
            self_: *mut whiteout_M2ColorAnimation,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2ColorAnimation_set_color(
            self_: *mut whiteout_M2ColorAnimation,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2ColorAnimation_get_alpha(
            self_: *mut whiteout_M2ColorAnimation,
        ) -> *mut whiteout_M2AnimationTrackI16;
        pub fn whiteout_m2_M2ColorAnimation_set_alpha(
            self_: *mut whiteout_M2ColorAnimation,
            value: *const whiteout_M2AnimationTrackI16,
        );
        // Light
        pub fn whiteout_m2_M2Light_new() -> *mut whiteout_M2Light;
        pub fn whiteout_m2_M2Light_delete(self_: *mut whiteout_M2Light);
        pub fn whiteout_m2_M2Light_get_type(self_: *mut whiteout_M2Light) -> u16;
        pub fn whiteout_m2_M2Light_set_type(self_: *mut whiteout_M2Light, value: u16);
        pub fn whiteout_m2_M2Light_get_boneId(self_: *mut whiteout_M2Light) -> i16;
        pub fn whiteout_m2_M2Light_set_boneId(self_: *mut whiteout_M2Light, value: i16);
        pub fn whiteout_m2_M2Light_get_position(
            self_: *mut whiteout_M2Light,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Light_set_position(
            self_: *mut whiteout_M2Light,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Light_get_ambientColor(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2Light_set_ambientColor(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2Light_get_ambientIntensity(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Light_set_ambientIntensity(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2Light_get_diffuseColor(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2Light_set_diffuseColor(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2Light_get_diffuseIntensity(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Light_set_diffuseIntensity(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2Light_get_attenuationStart(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Light_set_attenuationStart(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2Light_get_attenuationEnd(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Light_set_attenuationEnd(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2Light_get_visibility(
            self_: *mut whiteout_M2Light,
        ) -> *mut whiteout_M2AnimationTrackU8;
        pub fn whiteout_m2_M2Light_set_visibility(
            self_: *mut whiteout_M2Light,
            value: *const whiteout_M2AnimationTrackU8,
        );
        // CameraSpline
        pub fn whiteout_m2_M2CameraSpline_new() -> *mut whiteout_M2CameraSpline;
        pub fn whiteout_m2_M2CameraSpline_delete(self_: *mut whiteout_M2CameraSpline);
        pub fn whiteout_m2_M2CameraSpline_get_value(
            self_: *mut whiteout_M2CameraSpline,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2CameraSpline_set_value(
            self_: *mut whiteout_M2CameraSpline,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2CameraSpline_get_inTangent(
            self_: *mut whiteout_M2CameraSpline,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2CameraSpline_set_inTangent(
            self_: *mut whiteout_M2CameraSpline,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2CameraSpline_get_outTangent(
            self_: *mut whiteout_M2CameraSpline,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2CameraSpline_set_outTangent(
            self_: *mut whiteout_M2CameraSpline,
            value: *const core::ffi::c_void,
        );
        // Camera
        pub fn whiteout_m2_M2Camera_new() -> *mut whiteout_M2Camera;
        pub fn whiteout_m2_M2Camera_delete(self_: *mut whiteout_M2Camera);
        pub fn whiteout_m2_M2Camera_get_type(self_: *mut whiteout_M2Camera) -> u32;
        pub fn whiteout_m2_M2Camera_set_type(self_: *mut whiteout_M2Camera, value: u32);
        pub fn whiteout_m2_M2Camera_get_fieldOfView(self_: *mut whiteout_M2Camera) -> f32;
        pub fn whiteout_m2_M2Camera_set_fieldOfView(self_: *mut whiteout_M2Camera, value: f32);
        pub fn whiteout_m2_M2Camera_get_farClip(self_: *mut whiteout_M2Camera) -> f32;
        pub fn whiteout_m2_M2Camera_set_farClip(self_: *mut whiteout_M2Camera, value: f32);
        pub fn whiteout_m2_M2Camera_get_nearClip(self_: *mut whiteout_M2Camera) -> f32;
        pub fn whiteout_m2_M2Camera_set_nearClip(self_: *mut whiteout_M2Camera, value: f32);
        pub fn whiteout_m2_M2Camera_get_positions(
            self_: *mut whiteout_M2Camera,
        ) -> *mut whiteout_M2AnimationTrackM2CameraSpline;
        pub fn whiteout_m2_M2Camera_set_positions(
            self_: *mut whiteout_M2Camera,
            value: *const whiteout_M2AnimationTrackM2CameraSpline,
        );
        pub fn whiteout_m2_M2Camera_get_positionBase(
            self_: *mut whiteout_M2Camera,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Camera_set_positionBase(
            self_: *mut whiteout_M2Camera,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Camera_get_targetPositions(
            self_: *mut whiteout_M2Camera,
        ) -> *mut whiteout_M2AnimationTrackM2CameraSpline;
        pub fn whiteout_m2_M2Camera_set_targetPositions(
            self_: *mut whiteout_M2Camera,
            value: *const whiteout_M2AnimationTrackM2CameraSpline,
        );
        pub fn whiteout_m2_M2Camera_get_targetPositionBase(
            self_: *mut whiteout_M2Camera,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Camera_set_targetPositionBase(
            self_: *mut whiteout_M2Camera,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Camera_get_roll(
            self_: *mut whiteout_M2Camera,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Camera_set_roll(
            self_: *mut whiteout_M2Camera,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2Camera_get_fieldOfViewTrack(
            self_: *mut whiteout_M2Camera,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2Camera_set_fieldOfViewTrack(
            self_: *mut whiteout_M2Camera,
            value: *const whiteout_M2AnimationTrackF32,
        );
        // Attachment
        pub fn whiteout_m2_M2Attachment_new() -> *mut whiteout_M2Attachment;
        pub fn whiteout_m2_M2Attachment_delete(self_: *mut whiteout_M2Attachment);
        pub fn whiteout_m2_M2Attachment_get_id(self_: *mut whiteout_M2Attachment) -> u32;
        pub fn whiteout_m2_M2Attachment_set_id(self_: *mut whiteout_M2Attachment, value: u32);
        pub fn whiteout_m2_M2Attachment_get_boneId(self_: *mut whiteout_M2Attachment) -> u16;
        pub fn whiteout_m2_M2Attachment_set_boneId(self_: *mut whiteout_M2Attachment, value: u16);
        pub fn whiteout_m2_M2Attachment_get_unknown(self_: *mut whiteout_M2Attachment) -> u16;
        pub fn whiteout_m2_M2Attachment_set_unknown(self_: *mut whiteout_M2Attachment, value: u16);
        pub fn whiteout_m2_M2Attachment_get_position(
            self_: *mut whiteout_M2Attachment,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Attachment_set_position(
            self_: *mut whiteout_M2Attachment,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Attachment_get_animate(
            self_: *mut whiteout_M2Attachment,
        ) -> *mut whiteout_M2AnimationTrackU8;
        pub fn whiteout_m2_M2Attachment_set_animate(
            self_: *mut whiteout_M2Attachment,
            value: *const whiteout_M2AnimationTrackU8,
        );
        // RibbonEmitter
        pub fn whiteout_m2_M2RibbonEmitter_new() -> *mut whiteout_M2RibbonEmitter;
        pub fn whiteout_m2_M2RibbonEmitter_delete(self_: *mut whiteout_M2RibbonEmitter);
        pub fn whiteout_m2_M2RibbonEmitter_get_ribbonId(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m2_M2RibbonEmitter_set_ribbonId(
            self_: *mut whiteout_M2RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_boneId(self_: *mut whiteout_M2RibbonEmitter) -> u32;
        pub fn whiteout_m2_M2RibbonEmitter_set_boneId(
            self_: *mut whiteout_M2RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_position(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2RibbonEmitter_set_position(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_textureIndices_count(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> usize;
        pub fn whiteout_m2_M2RibbonEmitter_resize_textureIndices(
            self_: *mut whiteout_M2RibbonEmitter,
            count: usize,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_textureIndices_data(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *const u16;
        pub fn whiteout_m2_M2RibbonEmitter_assign_textureIndices(
            self_: *mut whiteout_M2RibbonEmitter,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_materialIndices_count(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> usize;
        pub fn whiteout_m2_M2RibbonEmitter_resize_materialIndices(
            self_: *mut whiteout_M2RibbonEmitter,
            count: usize,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_materialIndices_data(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *const u16;
        pub fn whiteout_m2_M2RibbonEmitter_assign_materialIndices(
            self_: *mut whiteout_M2RibbonEmitter,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_colorTrack(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2RibbonEmitter_set_colorTrack(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_alphaTrack(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackI16;
        pub fn whiteout_m2_M2RibbonEmitter_set_alphaTrack(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackI16,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_heightAbove(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2RibbonEmitter_set_heightAbove(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_heightBelow(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2RibbonEmitter_set_heightBelow(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_edgesPerSecond(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2RibbonEmitter_set_edgesPerSecond(
            self_: *mut whiteout_M2RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_edgeLifetime(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2RibbonEmitter_set_edgeLifetime(
            self_: *mut whiteout_M2RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_gravity(self_: *mut whiteout_M2RibbonEmitter)
            -> f32;
        pub fn whiteout_m2_M2RibbonEmitter_set_gravity(
            self_: *mut whiteout_M2RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_textureRows(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2RibbonEmitter_set_textureRows(
            self_: *mut whiteout_M2RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_textureCols(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2RibbonEmitter_set_textureCols(
            self_: *mut whiteout_M2RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_texSlot(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackU16;
        pub fn whiteout_m2_M2RibbonEmitter_set_texSlot(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackU16,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_visibility(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> *mut whiteout_M2AnimationTrackU8;
        pub fn whiteout_m2_M2RibbonEmitter_set_visibility(
            self_: *mut whiteout_M2RibbonEmitter,
            value: *const whiteout_M2AnimationTrackU8,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_priorityPlane(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> i16;
        pub fn whiteout_m2_M2RibbonEmitter_set_priorityPlane(
            self_: *mut whiteout_M2RibbonEmitter,
            value: i16,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_ribbonColorIndex(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> i8;
        pub fn whiteout_m2_M2RibbonEmitter_set_ribbonColorIndex(
            self_: *mut whiteout_M2RibbonEmitter,
            value: i8,
        );
        pub fn whiteout_m2_M2RibbonEmitter_get_textureTransformIndex(
            self_: *mut whiteout_M2RibbonEmitter,
        ) -> i8;
        pub fn whiteout_m2_M2RibbonEmitter_set_textureTransformIndex(
            self_: *mut whiteout_M2RibbonEmitter,
            value: i8,
        );
        // Box
        pub fn whiteout_m2_M2Box_new() -> *mut whiteout_M2Box;
        pub fn whiteout_m2_M2Box_delete(self_: *mut whiteout_M2Box);
        pub fn whiteout_m2_M2Box_get_minimum(self_: *mut whiteout_M2Box) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Box_set_minimum(
            self_: *mut whiteout_M2Box,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Box_get_maximum(self_: *mut whiteout_M2Box) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Box_set_maximum(
            self_: *mut whiteout_M2Box,
            value: *const core::ffi::c_void,
        );
        // ParticleEmitter
        pub fn whiteout_m2_M2ParticleEmitter_new() -> *mut whiteout_M2ParticleEmitter;
        pub fn whiteout_m2_M2ParticleEmitter_delete(self_: *mut whiteout_M2ParticleEmitter);
        pub fn whiteout_m2_M2ParticleEmitter_get_particleId(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m2_M2ParticleEmitter_set_particleId(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_flags(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m2_M2ParticleEmitter_set_flags(
            self_: *mut whiteout_M2ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_position(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2ParticleEmitter_set_position(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_boneId(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2ParticleEmitter_set_boneId(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_particleModelFilename(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> RawCString;
        pub fn whiteout_m2_M2ParticleEmitter_set_particleModelFilename(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_childEmittersModelFilename(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> RawCString;
        pub fn whiteout_m2_M2ParticleEmitter_set_childEmittersModelFilename(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_blendingType(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m2_M2ParticleEmitter_set_blendingType(
            self_: *mut whiteout_M2ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emitterType(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emitterType(
            self_: *mut whiteout_M2ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_particleColorIndex(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2ParticleEmitter_set_particleColorIndex(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_particleType(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m2_M2ParticleEmitter_set_particleType(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_headOrTail(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m2_M2ParticleEmitter_set_headOrTail(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_textureTilerotation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> i16;
        pub fn whiteout_m2_M2ParticleEmitter_set_textureTilerotation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: i16,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_rows(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2ParticleEmitter_set_rows(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_columns(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m2_M2ParticleEmitter_set_columns(
            self_: *mut whiteout_M2ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emissionSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emissionSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_speedVariation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_speedVariation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_verticalRange(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_verticalRange(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_horizontalRange(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_horizontalRange(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_gravity(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_gravity(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_lifespan(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_lifespan(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_lifespanVariation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_lifespanVariation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emissionRate(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emissionRate(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emissionRateVariation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emissionRateVariation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emissionAreaWidth(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emissionAreaWidth(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_emissionAreaLength(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_emissionAreaLength(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_zSource(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2ParticleEmitter_set_zSource(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackF32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_colorTrack(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2ParticleAnimationTrackVector3f;
        pub fn whiteout_m2_M2ParticleEmitter_set_colorTrack(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2ParticleAnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_scaleTrack(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2ParticleAnimationTrackVector2f;
        pub fn whiteout_m2_M2ParticleEmitter_set_scaleTrack(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2ParticleAnimationTrackVector2f,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_scaleVary(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2ParticleEmitter_set_scaleVary(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_tailLength(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_tailLength(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_twinkleSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_twinkleSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_twinklePercent(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_twinklePercent(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_twinkleScale(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2ParticleEmitter_set_twinkleScale(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_inheritVelocityScale(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_inheritVelocityScale(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_drag(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_drag(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_baseSpin(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_baseSpin(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_baseSpinVariation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_baseSpinVariation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_spinSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_spinSpeed(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_spinSpeedVariation(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_spinSpeedVariation(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_tumble(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2Box;
        pub fn whiteout_m2_M2ParticleEmitter_set_tumble(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2Box,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_windVector(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2ParticleEmitter_set_windVector(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_windTime(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_windTime(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_followSpeed1(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_followSpeed1(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_followScale1(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_followScale1(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_followSpeed2(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_followSpeed2(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_followScale2(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m2_M2ParticleEmitter_set_followScale2(
            self_: *mut whiteout_M2ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_splinePoints_count(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> usize;
        pub fn whiteout_m2_M2ParticleEmitter_resize_splinePoints(
            self_: *mut whiteout_M2ParticleEmitter,
            count: usize,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_splinePoints_data(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *const f32;
        pub fn whiteout_m2_M2ParticleEmitter_assign_splinePoints(
            self_: *mut whiteout_M2ParticleEmitter,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2ParticleEmitter_get_enabledIn(
            self_: *mut whiteout_M2ParticleEmitter,
        ) -> *mut whiteout_M2AnimationTrackU8;
        pub fn whiteout_m2_M2ParticleEmitter_set_enabledIn(
            self_: *mut whiteout_M2ParticleEmitter,
            value: *const whiteout_M2AnimationTrackU8,
        );
        // Event
        pub fn whiteout_m2_M2Event_new() -> *mut whiteout_M2Event;
        pub fn whiteout_m2_M2Event_delete(self_: *mut whiteout_M2Event);
        pub fn whiteout_m2_M2Event_get_identifier(self_: *mut whiteout_M2Event) -> u32;
        pub fn whiteout_m2_M2Event_set_identifier(self_: *mut whiteout_M2Event, value: u32);
        pub fn whiteout_m2_M2Event_get_data(self_: *mut whiteout_M2Event) -> u32;
        pub fn whiteout_m2_M2Event_set_data(self_: *mut whiteout_M2Event, value: u32);
        pub fn whiteout_m2_M2Event_get_boneId(self_: *mut whiteout_M2Event) -> u32;
        pub fn whiteout_m2_M2Event_set_boneId(self_: *mut whiteout_M2Event, value: u32);
        pub fn whiteout_m2_M2Event_get_position(
            self_: *mut whiteout_M2Event,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2Event_set_position(
            self_: *mut whiteout_M2Event,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2Event_get_enabled(
            self_: *mut whiteout_M2Event,
        ) -> *mut whiteout_M2AnimationTrackBase;
        pub fn whiteout_m2_M2Event_set_enabled(
            self_: *mut whiteout_M2Event,
            value: *const whiteout_M2AnimationTrackBase,
        );
        // PhysicsFrame
        pub fn whiteout_m2_M2PhysicsFrame_new() -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2PhysicsFrame_delete(self_: *mut whiteout_M2PhysicsFrame);
        pub fn whiteout_m2_M2PhysicsFrame_get_axisX(
            self_: *mut whiteout_M2PhysicsFrame,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PhysicsFrame_set_axisX(
            self_: *mut whiteout_M2PhysicsFrame,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PhysicsFrame_get_axisY(
            self_: *mut whiteout_M2PhysicsFrame,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PhysicsFrame_set_axisY(
            self_: *mut whiteout_M2PhysicsFrame,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PhysicsFrame_get_axisZ(
            self_: *mut whiteout_M2PhysicsFrame,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PhysicsFrame_set_axisZ(
            self_: *mut whiteout_M2PhysicsFrame,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PhysicsFrame_get_origin(
            self_: *mut whiteout_M2PhysicsFrame,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PhysicsFrame_set_origin(
            self_: *mut whiteout_M2PhysicsFrame,
            value: *const core::ffi::c_void,
        );
        // PhysicsBody
        pub fn whiteout_m2_M2PhysicsBody_new() -> *mut whiteout_M2PhysicsBody;
        pub fn whiteout_m2_M2PhysicsBody_delete(self_: *mut whiteout_M2PhysicsBody);
        pub fn whiteout_m2_M2PhysicsBody_get_type(self_: *mut whiteout_M2PhysicsBody) -> i32;
        pub fn whiteout_m2_M2PhysicsBody_set_type(self_: *mut whiteout_M2PhysicsBody, value: i32);
        pub fn whiteout_m2_M2PhysicsBody_get_boneIndex(self_: *mut whiteout_M2PhysicsBody) -> u16;
        pub fn whiteout_m2_M2PhysicsBody_set_boneIndex(
            self_: *mut whiteout_M2PhysicsBody,
            value: u16,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_position(
            self_: *mut whiteout_M2PhysicsBody,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PhysicsBody_set_position(
            self_: *mut whiteout_M2PhysicsBody,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_shapeIndex(self_: *mut whiteout_M2PhysicsBody) -> i32;
        pub fn whiteout_m2_M2PhysicsBody_set_shapeIndex(
            self_: *mut whiteout_M2PhysicsBody,
            value: i32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_shapeCount(self_: *mut whiteout_M2PhysicsBody) -> i32;
        pub fn whiteout_m2_M2PhysicsBody_set_shapeCount(
            self_: *mut whiteout_M2PhysicsBody,
            value: i32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_gravityScale(
            self_: *mut whiteout_M2PhysicsBody,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsBody_set_gravityScale(
            self_: *mut whiteout_M2PhysicsBody,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_inertiaScale(
            self_: *mut whiteout_M2PhysicsBody,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsBody_set_inertiaScale(
            self_: *mut whiteout_M2PhysicsBody,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_linearDamping(
            self_: *mut whiteout_M2PhysicsBody,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsBody_set_linearDamping(
            self_: *mut whiteout_M2PhysicsBody,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_angularDamping(
            self_: *mut whiteout_M2PhysicsBody,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsBody_set_angularDamping(
            self_: *mut whiteout_M2PhysicsBody,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_unknown28(self_: *mut whiteout_M2PhysicsBody) -> f32;
        pub fn whiteout_m2_M2PhysicsBody_set_unknown28(
            self_: *mut whiteout_M2PhysicsBody,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_unknown2c(self_: *mut whiteout_M2PhysicsBody) -> u16;
        pub fn whiteout_m2_M2PhysicsBody_set_unknown2c(
            self_: *mut whiteout_M2PhysicsBody,
            value: u16,
        );
        pub fn whiteout_m2_M2PhysicsBody_get_padding2e(self_: *mut whiteout_M2PhysicsBody) -> u16;
        pub fn whiteout_m2_M2PhysicsBody_set_padding2e(
            self_: *mut whiteout_M2PhysicsBody,
            value: u16,
        );
        // PhysicsShape
        pub fn whiteout_m2_M2PhysicsShape_new() -> *mut whiteout_M2PhysicsShape;
        pub fn whiteout_m2_M2PhysicsShape_delete(self_: *mut whiteout_M2PhysicsShape);
        pub fn whiteout_m2_M2PhysicsShape_get_shapeType(self_: *mut whiteout_M2PhysicsShape)
            -> i32;
        pub fn whiteout_m2_M2PhysicsShape_set_shapeType(
            self_: *mut whiteout_M2PhysicsShape,
            value: i32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_shapeIndex(
            self_: *mut whiteout_M2PhysicsShape,
        ) -> i16;
        pub fn whiteout_m2_M2PhysicsShape_set_shapeIndex(
            self_: *mut whiteout_M2PhysicsShape,
            value: i16,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_padding04(self_: *mut whiteout_M2PhysicsShape)
            -> u32;
        pub fn whiteout_m2_M2PhysicsShape_set_padding04(
            self_: *mut whiteout_M2PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_friction(self_: *mut whiteout_M2PhysicsShape) -> f32;
        pub fn whiteout_m2_M2PhysicsShape_set_friction(
            self_: *mut whiteout_M2PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_restitution(
            self_: *mut whiteout_M2PhysicsShape,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsShape_set_restitution(
            self_: *mut whiteout_M2PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_density(self_: *mut whiteout_M2PhysicsShape) -> f32;
        pub fn whiteout_m2_M2PhysicsShape_set_density(
            self_: *mut whiteout_M2PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_unknown14(self_: *mut whiteout_M2PhysicsShape)
            -> f32;
        pub fn whiteout_m2_M2PhysicsShape_set_unknown14(
            self_: *mut whiteout_M2PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_scale(self_: *mut whiteout_M2PhysicsShape) -> f32;
        pub fn whiteout_m2_M2PhysicsShape_set_scale(
            self_: *mut whiteout_M2PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_unknown1c(self_: *mut whiteout_M2PhysicsShape)
            -> u16;
        pub fn whiteout_m2_M2PhysicsShape_set_unknown1c(
            self_: *mut whiteout_M2PhysicsShape,
            value: u16,
        );
        pub fn whiteout_m2_M2PhysicsShape_get_padding1e(self_: *mut whiteout_M2PhysicsShape)
            -> u16;
        pub fn whiteout_m2_M2PhysicsShape_set_padding1e(
            self_: *mut whiteout_M2PhysicsShape,
            value: u16,
        );
        // BoxShape
        pub fn whiteout_m2_M2BoxShape_new() -> *mut whiteout_M2BoxShape;
        pub fn whiteout_m2_M2BoxShape_delete(self_: *mut whiteout_M2BoxShape);
        pub fn whiteout_m2_M2BoxShape_get_frame(
            self_: *mut whiteout_M2BoxShape,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2BoxShape_set_frame(
            self_: *mut whiteout_M2BoxShape,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2BoxShape_get_halfExtents(
            self_: *mut whiteout_M2BoxShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2BoxShape_set_halfExtents(
            self_: *mut whiteout_M2BoxShape,
            value: *const core::ffi::c_void,
        );
        // CapsuleShape
        pub fn whiteout_m2_M2CapsuleShape_new() -> *mut whiteout_M2CapsuleShape;
        pub fn whiteout_m2_M2CapsuleShape_delete(self_: *mut whiteout_M2CapsuleShape);
        pub fn whiteout_m2_M2CapsuleShape_get_localPosition1(
            self_: *mut whiteout_M2CapsuleShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2CapsuleShape_set_localPosition1(
            self_: *mut whiteout_M2CapsuleShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2CapsuleShape_get_localPosition2(
            self_: *mut whiteout_M2CapsuleShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2CapsuleShape_set_localPosition2(
            self_: *mut whiteout_M2CapsuleShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2CapsuleShape_get_radius(self_: *mut whiteout_M2CapsuleShape) -> f32;
        pub fn whiteout_m2_M2CapsuleShape_set_radius(
            self_: *mut whiteout_M2CapsuleShape,
            value: f32,
        );
        // SphereShape
        pub fn whiteout_m2_M2SphereShape_new() -> *mut whiteout_M2SphereShape;
        pub fn whiteout_m2_M2SphereShape_delete(self_: *mut whiteout_M2SphereShape);
        pub fn whiteout_m2_M2SphereShape_get_localPosition(
            self_: *mut whiteout_M2SphereShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2SphereShape_set_localPosition(
            self_: *mut whiteout_M2SphereShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2SphereShape_get_radius(self_: *mut whiteout_M2SphereShape) -> f32;
        pub fn whiteout_m2_M2SphereShape_set_radius(self_: *mut whiteout_M2SphereShape, value: f32);
        // PolytopeHalfEdge
        pub fn whiteout_m2_M2PolytopeHalfEdge_new() -> *mut whiteout_M2PolytopeHalfEdge;
        pub fn whiteout_m2_M2PolytopeHalfEdge_delete(self_: *mut whiteout_M2PolytopeHalfEdge);
        pub fn whiteout_m2_M2PolytopeHalfEdge_get_twinOffset(
            self_: *mut whiteout_M2PolytopeHalfEdge,
        ) -> i8;
        pub fn whiteout_m2_M2PolytopeHalfEdge_set_twinOffset(
            self_: *mut whiteout_M2PolytopeHalfEdge,
            value: i8,
        );
        pub fn whiteout_m2_M2PolytopeHalfEdge_get_originVertex(
            self_: *mut whiteout_M2PolytopeHalfEdge,
        ) -> u8;
        pub fn whiteout_m2_M2PolytopeHalfEdge_set_originVertex(
            self_: *mut whiteout_M2PolytopeHalfEdge,
            value: u8,
        );
        pub fn whiteout_m2_M2PolytopeHalfEdge_get_faceIndex(
            self_: *mut whiteout_M2PolytopeHalfEdge,
        ) -> u8;
        pub fn whiteout_m2_M2PolytopeHalfEdge_set_faceIndex(
            self_: *mut whiteout_M2PolytopeHalfEdge,
            value: u8,
        );
        pub fn whiteout_m2_M2PolytopeHalfEdge_get_nextEdge(
            self_: *mut whiteout_M2PolytopeHalfEdge,
        ) -> u8;
        pub fn whiteout_m2_M2PolytopeHalfEdge_set_nextEdge(
            self_: *mut whiteout_M2PolytopeHalfEdge,
            value: u8,
        );
        // PolytopeShape
        pub fn whiteout_m2_M2PolytopeShape_new() -> *mut whiteout_M2PolytopeShape;
        pub fn whiteout_m2_M2PolytopeShape_delete(self_: *mut whiteout_M2PolytopeShape);
        pub fn whiteout_m2_M2PolytopeShape_get_vertices_count(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> usize;
        pub fn whiteout_m2_M2PolytopeShape_resize_vertices(
            self_: *mut whiteout_M2PolytopeShape,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_vertices_data(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> *const f32;
        pub fn whiteout_m2_M2PolytopeShape_assign_vertices(
            self_: *mut whiteout_M2PolytopeShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_facePlanes_count(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> usize;
        pub fn whiteout_m2_M2PolytopeShape_resize_facePlanes(
            self_: *mut whiteout_M2PolytopeShape,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_facePlanes_data(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> *const f32;
        pub fn whiteout_m2_M2PolytopeShape_assign_facePlanes(
            self_: *mut whiteout_M2PolytopeShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_faceFirstEdges_count(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> usize;
        pub fn whiteout_m2_M2PolytopeShape_resize_faceFirstEdges(
            self_: *mut whiteout_M2PolytopeShape,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_faceFirstEdges_data(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> *const u8;
        pub fn whiteout_m2_M2PolytopeShape_assign_faceFirstEdges(
            self_: *mut whiteout_M2PolytopeShape,
            data: *const u8,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_edges_count(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> usize;
        pub fn whiteout_m2_M2PolytopeShape_resize_edges(
            self_: *mut whiteout_M2PolytopeShape,
            count: usize,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_edges_at(
            self_: *mut whiteout_M2PolytopeShape,
            index: usize,
        ) -> *mut whiteout_M2PolytopeHalfEdge;
        pub fn whiteout_m2_M2PolytopeShape_get_centroid(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2PolytopeShape_set_centroid(
            self_: *mut whiteout_M2PolytopeShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_volume(self_: *mut whiteout_M2PolytopeShape) -> f32;
        pub fn whiteout_m2_M2PolytopeShape_set_volume(
            self_: *mut whiteout_M2PolytopeShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_surfaceArea(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> f32;
        pub fn whiteout_m2_M2PolytopeShape_set_surfaceArea(
            self_: *mut whiteout_M2PolytopeShape,
            value: f32,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_padding04(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> u32;
        pub fn whiteout_m2_M2PolytopeShape_set_padding04(
            self_: *mut whiteout_M2PolytopeShape,
            value: u32,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_padding14(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> u32;
        pub fn whiteout_m2_M2PolytopeShape_set_padding14(
            self_: *mut whiteout_M2PolytopeShape,
            value: u32,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_padding2c(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> u32;
        pub fn whiteout_m2_M2PolytopeShape_set_padding2c(
            self_: *mut whiteout_M2PolytopeShape,
            value: u32,
        );
        pub fn whiteout_m2_M2PolytopeShape_get_padding4c(
            self_: *mut whiteout_M2PolytopeShape,
        ) -> u32;
        pub fn whiteout_m2_M2PolytopeShape_set_padding4c(
            self_: *mut whiteout_M2PolytopeShape,
            value: u32,
        );
        // PhysicsJoint
        pub fn whiteout_m2_M2PhysicsJoint_new() -> *mut whiteout_M2PhysicsJoint;
        pub fn whiteout_m2_M2PhysicsJoint_delete(self_: *mut whiteout_M2PhysicsJoint);
        pub fn whiteout_m2_M2PhysicsJoint_get_bodyAIndex(
            self_: *mut whiteout_M2PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m2_M2PhysicsJoint_set_bodyAIndex(
            self_: *mut whiteout_M2PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2PhysicsJoint_get_bodyBIndex(
            self_: *mut whiteout_M2PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m2_M2PhysicsJoint_set_bodyBIndex(
            self_: *mut whiteout_M2PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2PhysicsJoint_get_padding08(self_: *mut whiteout_M2PhysicsJoint)
            -> u32;
        pub fn whiteout_m2_M2PhysicsJoint_set_padding08(
            self_: *mut whiteout_M2PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2PhysicsJoint_get_jointType(self_: *mut whiteout_M2PhysicsJoint)
            -> i32;
        pub fn whiteout_m2_M2PhysicsJoint_set_jointType(
            self_: *mut whiteout_M2PhysicsJoint,
            value: i32,
        );
        pub fn whiteout_m2_M2PhysicsJoint_get_jointId(self_: *mut whiteout_M2PhysicsJoint) -> i16;
        pub fn whiteout_m2_M2PhysicsJoint_set_jointId(
            self_: *mut whiteout_M2PhysicsJoint,
            value: i16,
        );
        // WeldJoint
        pub fn whiteout_m2_M2WeldJoint_new() -> *mut whiteout_M2WeldJoint;
        pub fn whiteout_m2_M2WeldJoint_delete(self_: *mut whiteout_M2WeldJoint);
        pub fn whiteout_m2_M2WeldJoint_get_frameA(
            self_: *mut whiteout_M2WeldJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2WeldJoint_set_frameA(
            self_: *mut whiteout_M2WeldJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2WeldJoint_get_frameB(
            self_: *mut whiteout_M2WeldJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2WeldJoint_set_frameB(
            self_: *mut whiteout_M2WeldJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2WeldJoint_get_angularFrequencyHz(
            self_: *mut whiteout_M2WeldJoint,
        ) -> f32;
        pub fn whiteout_m2_M2WeldJoint_set_angularFrequencyHz(
            self_: *mut whiteout_M2WeldJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2WeldJoint_get_angularDampingRatio(
            self_: *mut whiteout_M2WeldJoint,
        ) -> f32;
        pub fn whiteout_m2_M2WeldJoint_set_angularDampingRatio(
            self_: *mut whiteout_M2WeldJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2WeldJoint_get_linearFrequencyHz(
            self_: *mut whiteout_M2WeldJoint,
        ) -> f32;
        pub fn whiteout_m2_M2WeldJoint_set_linearFrequencyHz(
            self_: *mut whiteout_M2WeldJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2WeldJoint_get_linearDampingRatio(
            self_: *mut whiteout_M2WeldJoint,
        ) -> f32;
        pub fn whiteout_m2_M2WeldJoint_set_linearDampingRatio(
            self_: *mut whiteout_M2WeldJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2WeldJoint_get_unknown70(self_: *mut whiteout_M2WeldJoint) -> f32;
        pub fn whiteout_m2_M2WeldJoint_set_unknown70(self_: *mut whiteout_M2WeldJoint, value: f32);
        // SphericalJoint
        pub fn whiteout_m2_M2SphericalJoint_new() -> *mut whiteout_M2SphericalJoint;
        pub fn whiteout_m2_M2SphericalJoint_delete(self_: *mut whiteout_M2SphericalJoint);
        pub fn whiteout_m2_M2SphericalJoint_get_anchorA(
            self_: *mut whiteout_M2SphericalJoint,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2SphericalJoint_set_anchorA(
            self_: *mut whiteout_M2SphericalJoint,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2SphericalJoint_get_anchorB(
            self_: *mut whiteout_M2SphericalJoint,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2SphericalJoint_set_anchorB(
            self_: *mut whiteout_M2SphericalJoint,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2SphericalJoint_get_frictionTorque(
            self_: *mut whiteout_M2SphericalJoint,
        ) -> f32;
        pub fn whiteout_m2_M2SphericalJoint_set_frictionTorque(
            self_: *mut whiteout_M2SphericalJoint,
            value: f32,
        );
        // ShoulderJoint
        pub fn whiteout_m2_M2ShoulderJoint_new() -> *mut whiteout_M2ShoulderJoint;
        pub fn whiteout_m2_M2ShoulderJoint_delete(self_: *mut whiteout_M2ShoulderJoint);
        pub fn whiteout_m2_M2ShoulderJoint_get_frameA(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2ShoulderJoint_set_frameA(
            self_: *mut whiteout_M2ShoulderJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_frameB(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2ShoulderJoint_set_frameB(
            self_: *mut whiteout_M2ShoulderJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_lowerTwistAngle(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_lowerTwistAngle(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_upperTwistAngle(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_upperTwistAngle(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_coneAngle(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_coneAngle(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_maxMotorTorque(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_maxMotorTorque(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_motorMode(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> u32;
        pub fn whiteout_m2_M2ShoulderJoint_set_motorMode(
            self_: *mut whiteout_M2ShoulderJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_motorFrequencyHz(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_motorFrequencyHz(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2ShoulderJoint_get_motorDampingRatio(
            self_: *mut whiteout_M2ShoulderJoint,
        ) -> f32;
        pub fn whiteout_m2_M2ShoulderJoint_set_motorDampingRatio(
            self_: *mut whiteout_M2ShoulderJoint,
            value: f32,
        );
        // PrismaticJoint
        pub fn whiteout_m2_M2PrismaticJoint_new() -> *mut whiteout_M2PrismaticJoint;
        pub fn whiteout_m2_M2PrismaticJoint_delete(self_: *mut whiteout_M2PrismaticJoint);
        pub fn whiteout_m2_M2PrismaticJoint_get_frameA(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2PrismaticJoint_set_frameA(
            self_: *mut whiteout_M2PrismaticJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_frameB(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2PrismaticJoint_set_frameB(
            self_: *mut whiteout_M2PrismaticJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_lowerLimit(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_lowerLimit(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_upperLimit(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_upperLimit(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_unknown68(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_unknown68(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_maxMotorForce(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_maxMotorForce(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_unknown70(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_unknown70(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_motorMode(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> u32;
        pub fn whiteout_m2_M2PrismaticJoint_set_motorMode(
            self_: *mut whiteout_M2PrismaticJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_motorFrequencyHz(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_motorFrequencyHz(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2PrismaticJoint_get_motorDampingRatio(
            self_: *mut whiteout_M2PrismaticJoint,
        ) -> f32;
        pub fn whiteout_m2_M2PrismaticJoint_set_motorDampingRatio(
            self_: *mut whiteout_M2PrismaticJoint,
            value: f32,
        );
        // RevoluteJoint
        pub fn whiteout_m2_M2RevoluteJoint_new() -> *mut whiteout_M2RevoluteJoint;
        pub fn whiteout_m2_M2RevoluteJoint_delete(self_: *mut whiteout_M2RevoluteJoint);
        pub fn whiteout_m2_M2RevoluteJoint_get_frameA(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2RevoluteJoint_set_frameA(
            self_: *mut whiteout_M2RevoluteJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_frameB(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> *mut whiteout_M2PhysicsFrame;
        pub fn whiteout_m2_M2RevoluteJoint_set_frameB(
            self_: *mut whiteout_M2RevoluteJoint,
            value: *const whiteout_M2PhysicsFrame,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_lowerAngle(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> f32;
        pub fn whiteout_m2_M2RevoluteJoint_set_lowerAngle(
            self_: *mut whiteout_M2RevoluteJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_upperAngle(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> f32;
        pub fn whiteout_m2_M2RevoluteJoint_set_upperAngle(
            self_: *mut whiteout_M2RevoluteJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_maxMotorTorque(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> f32;
        pub fn whiteout_m2_M2RevoluteJoint_set_maxMotorTorque(
            self_: *mut whiteout_M2RevoluteJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_motorMode(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> u32;
        pub fn whiteout_m2_M2RevoluteJoint_set_motorMode(
            self_: *mut whiteout_M2RevoluteJoint,
            value: u32,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_motorFrequencyHz(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> f32;
        pub fn whiteout_m2_M2RevoluteJoint_set_motorFrequencyHz(
            self_: *mut whiteout_M2RevoluteJoint,
            value: f32,
        );
        pub fn whiteout_m2_M2RevoluteJoint_get_motorDampingRatio(
            self_: *mut whiteout_M2RevoluteJoint,
        ) -> f32;
        pub fn whiteout_m2_M2RevoluteJoint_set_motorDampingRatio(
            self_: *mut whiteout_M2RevoluteJoint,
            value: f32,
        );
        // DistanceJoint
        pub fn whiteout_m2_M2DistanceJoint_new() -> *mut whiteout_M2DistanceJoint;
        pub fn whiteout_m2_M2DistanceJoint_delete(self_: *mut whiteout_M2DistanceJoint);
        pub fn whiteout_m2_M2DistanceJoint_get_localAnchorA(
            self_: *mut whiteout_M2DistanceJoint,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2DistanceJoint_set_localAnchorA(
            self_: *mut whiteout_M2DistanceJoint,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2DistanceJoint_get_localAnchorB(
            self_: *mut whiteout_M2DistanceJoint,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m2_M2DistanceJoint_set_localAnchorB(
            self_: *mut whiteout_M2DistanceJoint,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m2_M2DistanceJoint_get_distance(
            self_: *mut whiteout_M2DistanceJoint,
        ) -> f32;
        pub fn whiteout_m2_M2DistanceJoint_set_distance(
            self_: *mut whiteout_M2DistanceJoint,
            value: f32,
        );
        // PhysicsTuning
        pub fn whiteout_m2_M2PhysicsTuning_new() -> *mut whiteout_M2PhysicsTuning;
        pub fn whiteout_m2_M2PhysicsTuning_delete(self_: *mut whiteout_M2PhysicsTuning);
        pub fn whiteout_m2_M2PhysicsTuning_values_size() -> usize;
        pub fn whiteout_m2_M2PhysicsTuning_get_values_at(
            self_: *mut whiteout_M2PhysicsTuning,
            index: usize,
        ) -> f32;
        pub fn whiteout_m2_M2PhysicsTuning_set_values_at(
            self_: *mut whiteout_M2PhysicsTuning,
            index: usize,
            value: f32,
        );
        // PhysicsUnknownChunk
        pub fn whiteout_m2_M2PhysicsUnknownChunk_new() -> *mut whiteout_M2PhysicsUnknownChunk;
        pub fn whiteout_m2_M2PhysicsUnknownChunk_delete(self_: *mut whiteout_M2PhysicsUnknownChunk);
        pub fn whiteout_m2_M2PhysicsUnknownChunk_tag_size() -> usize;
        pub fn whiteout_m2_M2PhysicsUnknownChunk_get_tag_at(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
            index: usize,
        ) -> i8;
        pub fn whiteout_m2_M2PhysicsUnknownChunk_set_tag_at(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
            index: usize,
            value: i8,
        );
        pub fn whiteout_m2_M2PhysicsUnknownChunk_get_data_count(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsUnknownChunk_resize_data(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsUnknownChunk_get_data_data(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
        ) -> *const u8;
        pub fn whiteout_m2_M2PhysicsUnknownChunk_assign_data(
            self_: *mut whiteout_M2PhysicsUnknownChunk,
            data: *const u8,
            count: usize,
        );
        // PhysicsData
        pub fn whiteout_m2_M2PhysicsData_new() -> *mut whiteout_M2PhysicsData;
        pub fn whiteout_m2_M2PhysicsData_delete(self_: *mut whiteout_M2PhysicsData);
        pub fn whiteout_m2_M2PhysicsData_get_version(self_: *mut whiteout_M2PhysicsData) -> u16;
        pub fn whiteout_m2_M2PhysicsData_set_version(
            self_: *mut whiteout_M2PhysicsData,
            value: u16,
        );
        pub fn whiteout_m2_M2PhysicsData_get_bodies_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_bodies(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_bodies_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PhysicsBody;
        pub fn whiteout_m2_M2PhysicsData_get_shapes_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_shapes(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_shapes_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PhysicsShape;
        pub fn whiteout_m2_M2PhysicsData_get_boxShapes_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_boxShapes(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_boxShapes_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2BoxShape;
        pub fn whiteout_m2_M2PhysicsData_get_capsuleShapes_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_capsuleShapes(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_capsuleShapes_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2CapsuleShape;
        pub fn whiteout_m2_M2PhysicsData_get_sphereShapes_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_sphereShapes(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_sphereShapes_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2SphereShape;
        pub fn whiteout_m2_M2PhysicsData_get_polytopeShapes_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_polytopeShapes(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_polytopeShapes_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PolytopeShape;
        pub fn whiteout_m2_M2PhysicsData_get_joints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_joints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_joints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PhysicsJoint;
        pub fn whiteout_m2_M2PhysicsData_get_weldJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_weldJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_weldJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2WeldJoint;
        pub fn whiteout_m2_M2PhysicsData_get_sphericalJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_sphericalJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_sphericalJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2SphericalJoint;
        pub fn whiteout_m2_M2PhysicsData_get_shoulderJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_shoulderJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_shoulderJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2ShoulderJoint;
        pub fn whiteout_m2_M2PhysicsData_get_prismaticJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_prismaticJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_prismaticJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PrismaticJoint;
        pub fn whiteout_m2_M2PhysicsData_get_revoluteJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_revoluteJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_revoluteJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2RevoluteJoint;
        pub fn whiteout_m2_M2PhysicsData_get_distanceJoints_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_distanceJoints(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_distanceJoints_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2DistanceJoint;
        pub fn whiteout_m2_M2PhysicsData_get_tuning_count(
            self_: *mut whiteout_M2PhysicsData,
        ) -> usize;
        pub fn whiteout_m2_M2PhysicsData_resize_tuning(
            self_: *mut whiteout_M2PhysicsData,
            count: usize,
        );
        pub fn whiteout_m2_M2PhysicsData_get_tuning_at(
            self_: *mut whiteout_M2PhysicsData,
            index: usize,
        ) -> *mut whiteout_M2PhysicsTuning;
        // BoneOverride
        pub fn whiteout_m2_M2BoneOverride_new() -> *mut whiteout_M2BoneOverride;
        pub fn whiteout_m2_M2BoneOverride_delete(self_: *mut whiteout_M2BoneOverride);
        pub fn whiteout_m2_M2BoneOverride_get_boneIndex(self_: *mut whiteout_M2BoneOverride)
            -> u16;
        pub fn whiteout_m2_M2BoneOverride_set_boneIndex(
            self_: *mut whiteout_M2BoneOverride,
            value: u16,
        );
        // BoneOverrideSet
        pub fn whiteout_m2_M2BoneOverrideSet_new() -> *mut whiteout_M2BoneOverrideSet;
        pub fn whiteout_m2_M2BoneOverrideSet_delete(self_: *mut whiteout_M2BoneOverrideSet);
        pub fn whiteout_m2_M2BoneOverrideSet_get_version(
            self_: *mut whiteout_M2BoneOverrideSet,
        ) -> u32;
        pub fn whiteout_m2_M2BoneOverrideSet_set_version(
            self_: *mut whiteout_M2BoneOverrideSet,
            value: u32,
        );
        pub fn whiteout_m2_M2BoneOverrideSet_get_overrides_count(
            self_: *mut whiteout_M2BoneOverrideSet,
        ) -> usize;
        pub fn whiteout_m2_M2BoneOverrideSet_resize_overrides(
            self_: *mut whiteout_M2BoneOverrideSet,
            count: usize,
        );
        pub fn whiteout_m2_M2BoneOverrideSet_get_overrides_at(
            self_: *mut whiteout_M2BoneOverrideSet,
            index: usize,
        ) -> *mut whiteout_M2BoneOverride;
        // Model
        pub fn whiteout_m2_M2Model_new() -> *mut whiteout_M2Model;
        pub fn whiteout_m2_M2Model_delete(self_: *mut whiteout_M2Model);
        pub fn whiteout_m2_M2Model_get_modelName(self_: *mut whiteout_M2Model) -> RawCString;
        pub fn whiteout_m2_M2Model_set_modelName(
            self_: *mut whiteout_M2Model,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m2_M2Model_get_globalFlags(
            self_: *mut whiteout_M2Model,
        ) -> *mut whiteout_M2GlobalFlags;
        pub fn whiteout_m2_M2Model_set_globalFlags(
            self_: *mut whiteout_M2Model,
            value: *const whiteout_M2GlobalFlags,
        );
        pub fn whiteout_m2_M2Model_get_globalLoops_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_globalLoops(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_globalLoops_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2GlobalSequence;
        pub fn whiteout_m2_M2Model_get_sequences_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_sequences(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_sequences_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Sequence;
        pub fn whiteout_m2_M2Model_get_sequenceIdxHashById_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_sequenceIdxHashById(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_sequenceIdxHashById_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_sequenceIdxHashById(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_bones_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_bones(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_bones_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Bone;
        pub fn whiteout_m2_M2Model_get_keyBoneIds_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_keyBoneIds(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_keyBoneIds_data(self_: *mut whiteout_M2Model) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_keyBoneIds(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_vertices_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_vertices(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_vertices_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Vertex;
        pub fn whiteout_m2_M2Model_get_skinProfiles_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_skinProfiles(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_skinProfiles_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2SkinProfile;
        pub fn whiteout_m2_M2Model_get_lodProfiles_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_lodProfiles(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_lodProfiles_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2SkinProfile;
        pub fn whiteout_m2_M2Model_get_numSkinProfiles(self_: *mut whiteout_M2Model) -> u32;
        pub fn whiteout_m2_M2Model_set_numSkinProfiles(self_: *mut whiteout_M2Model, value: u32);
        pub fn whiteout_m2_M2Model_get_colors_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_colors(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_colors_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2ColorAnimation;
        pub fn whiteout_m2_M2Model_get_textures_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_textures(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_textures_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Texture;
        pub fn whiteout_m2_M2Model_get_textureWeights_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureWeights(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureWeights_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2TextureWeight;
        pub fn whiteout_m2_M2Model_get_textureTransforms_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureTransforms(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureTransforms_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2TextureTransform;
        pub fn whiteout_m2_M2Model_get_textureIndicesById_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureIndicesById(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureIndicesById_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureIndicesById(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_materials_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_materials(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_materials_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Material;
        pub fn whiteout_m2_M2Model_get_boneCombos_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_boneCombos(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_boneCombos_data(self_: *mut whiteout_M2Model) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_boneCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureCombos_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureCombos(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_textureCombos_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureCoordCombos_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureCoordCombos(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureCoordCombos_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureCoordCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureWeightCombos_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureWeightCombos(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureWeightCombos_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureWeightCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureTransformCombos_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureTransformCombos(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureTransformCombos_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureTransformCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_bounding(
            self_: *mut whiteout_M2Model,
        ) -> *mut whiteout_M2Extent;
        pub fn whiteout_m2_M2Model_set_bounding(
            self_: *mut whiteout_M2Model,
            value: *const whiteout_M2Extent,
        );
        pub fn whiteout_m2_M2Model_get_collision(
            self_: *mut whiteout_M2Model,
        ) -> *mut whiteout_M2Extent;
        pub fn whiteout_m2_M2Model_set_collision(
            self_: *mut whiteout_M2Model,
            value: *const whiteout_M2Extent,
        );
        pub fn whiteout_m2_M2Model_get_collisionTriangleIndices_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_collisionTriangleIndices(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_collisionTriangleIndices_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_collisionTriangleIndices(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_collisionVertices_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_collisionVertices(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_collisionVertices_data(
            self_: *mut whiteout_M2Model,
        ) -> *const f32;
        pub fn whiteout_m2_M2Model_assign_collisionVertices(
            self_: *mut whiteout_M2Model,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_collisionFaceNormals_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_collisionFaceNormals(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_collisionFaceNormals_data(
            self_: *mut whiteout_M2Model,
        ) -> *const f32;
        pub fn whiteout_m2_M2Model_assign_collisionFaceNormals(
            self_: *mut whiteout_M2Model,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_attachments_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_attachments(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_attachments_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Attachment;
        pub fn whiteout_m2_M2Model_get_attachmentIndicesById_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_attachmentIndicesById(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_attachmentIndicesById_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_attachmentIndicesById(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_events_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_events(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_events_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Event;
        pub fn whiteout_m2_M2Model_get_lights_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_lights(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_lights_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Light;
        pub fn whiteout_m2_M2Model_get_cameras_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_cameras(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_cameras_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Camera;
        pub fn whiteout_m2_M2Model_get_cameraIndicesById_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_cameraIndicesById(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_cameraIndicesById_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_cameraIndicesById(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_ribbonEmitters_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_ribbonEmitters(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_ribbonEmitters_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2RibbonEmitter;
        pub fn whiteout_m2_M2Model_get_particleEmitters_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_particleEmitters(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_particleEmitters_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2ParticleEmitter;
        pub fn whiteout_m2_M2Model_get_textureCombinerCombos_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureCombinerCombos(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureCombinerCombos_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureCombinerCombos(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_playableAnimationLookup_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_playableAnimationLookup(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_playableAnimationLookup_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u32;
        pub fn whiteout_m2_M2Model_assign_playableAnimationLookup(
            self_: *mut whiteout_M2Model,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureFlipbooks_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_textureFlipbooks(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_textureFlipbooks_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_textureFlipbooks(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_texture_ids_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_texture_ids(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_texture_ids_data(self_: *mut whiteout_M2Model)
            -> *const u32;
        pub fn whiteout_m2_M2Model_assign_texture_ids(
            self_: *mut whiteout_M2Model,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentSequenceReplacements_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_parentSequenceReplacements(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentSequenceReplacements_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u16;
        pub fn whiteout_m2_M2Model_assign_parentSequenceReplacements(
            self_: *mut whiteout_M2Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentTextureWeights_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_parentTextureWeights(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentTextureWeights_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2TextureWeight;
        pub fn whiteout_m2_M2Model_get_parentSequenceBounds_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_parentSequenceBounds(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentSequenceBounds_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2Extent;
        pub fn whiteout_m2_M2Model_get_parentEventData_count(self_: *mut whiteout_M2Model)
            -> usize;
        pub fn whiteout_m2_M2Model_resize_parentEventData(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_parentEventData_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2AnimationTrackBase;
        pub fn whiteout_m2_M2Model_get_recursiveParticleModelIds_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_recursiveParticleModelIds(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_recursiveParticleModelIds_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u32;
        pub fn whiteout_m2_M2Model_assign_recursiveParticleModelIds(
            self_: *mut whiteout_M2Model,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_geometryParticleModelIds_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_geometryParticleModelIds(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_geometryParticleModelIds_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u32;
        pub fn whiteout_m2_M2Model_assign_geometryParticleModelIds(
            self_: *mut whiteout_M2Model,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_particleGeosets_count(self_: *mut whiteout_M2Model)
            -> usize;
        pub fn whiteout_m2_M2Model_resize_particleGeosets(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_particleGeosets_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2ParticleGeosetData;
        pub fn whiteout_m2_M2Model_get_boneOverrides_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_boneOverrides(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_boneOverrides_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2BoneOverrideSet;
        pub fn whiteout_m2_M2Model_get_boneFileIds_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_boneFileIds(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_boneFileIds_data(self_: *mut whiteout_M2Model)
            -> *const u32;
        pub fn whiteout_m2_M2Model_assign_boneFileIds(
            self_: *mut whiteout_M2Model,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_edgeFadeEntries_count(self_: *mut whiteout_M2Model)
            -> usize;
        pub fn whiteout_m2_M2Model_resize_edgeFadeEntries(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_edgeFadeEntries_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2EdgeFadeData;
        pub fn whiteout_m2_M2Model_get_nerfEntries_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_nerfEntries(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_nerfEntries_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2DistanceFadeData;
        pub fn whiteout_m2_M2Model_get_detailedLightEntries_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_detailedLightEntries(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_detailedLightEntries_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2DetailedLightData;
        pub fn whiteout_m2_M2Model_get_debugOcclusionEntries_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_debugOcclusionEntries(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_debugOcclusionEntries_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2DebugOcclusionData;
        pub fn whiteout_m2_M2Model_get_animFrameData_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_animFrameData(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_animFrameData_data(
            self_: *mut whiteout_M2Model,
        ) -> *const u8;
        pub fn whiteout_m2_M2Model_assign_animFrameData(
            self_: *mut whiteout_M2Model,
            data: *const u8,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_dpivData_count(self_: *mut whiteout_M2Model) -> usize;
        pub fn whiteout_m2_M2Model_resize_dpivData(self_: *mut whiteout_M2Model, count: usize);
        pub fn whiteout_m2_M2Model_get_dpivData_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2PivotDisplacementData;
        pub fn whiteout_m2_M2Model_get_texturedLightEntries_count(
            self_: *mut whiteout_M2Model,
        ) -> usize;
        pub fn whiteout_m2_M2Model_resize_texturedLightEntries(
            self_: *mut whiteout_M2Model,
            count: usize,
        );
        pub fn whiteout_m2_M2Model_get_texturedLightEntries_at(
            self_: *mut whiteout_M2Model,
            index: usize,
        ) -> *mut whiteout_M2TexturedLightData;
        // Parser
        pub fn whiteout_m2_M2Parser_new() -> *mut whiteout_M2Parser;
        pub fn whiteout_m2_M2Parser_delete(self_: *mut whiteout_M2Parser);
        pub fn whiteout_m2_M2Parser_parse(
            self_: *mut whiteout_M2Parser,
            fs: *mut core::ffi::c_void,
            file_path: *const core::ffi::c_char,
        ) -> *mut whiteout_M2Model;
        pub fn whiteout_m2_M2Parser_parse_cascFs_buffer(
            self_: *mut whiteout_M2Parser,
            casc_fs: *const u8,
            casc_fs_size: usize,
            buffer: *const u8,
            buffer_size: usize,
        ) -> *mut whiteout_M2Model;
        pub fn whiteout_m2_M2Parser_setLazyAnimations(self_: *mut whiteout_M2Parser, enable: i32);
        pub fn whiteout_m2_M2Parser_hasIssues(self_: *mut whiteout_M2Parser) -> i32;
        pub fn whiteout_m2_M2Parser_getIssues_count(self_: *mut whiteout_M2Parser) -> usize;
        pub fn whiteout_m2_M2Parser_getIssues_at(
            self_: *mut whiteout_M2Parser,
            index: usize,
        ) -> RawCString;
        // WriteOptions
        pub fn whiteout_m2_M2WriteOptions_new() -> *mut whiteout_M2WriteOptions;
        pub fn whiteout_m2_M2WriteOptions_delete(self_: *mut whiteout_M2WriteOptions);
        pub fn whiteout_m2_M2WriteOptions_get_m2Version(self_: *mut whiteout_M2WriteOptions)
            -> u32;
        pub fn whiteout_m2_M2WriteOptions_set_m2Version(
            self_: *mut whiteout_M2WriteOptions,
            value: u32,
        );
        pub fn whiteout_m2_M2WriteOptions_get_emitSkeleton(
            self_: *mut whiteout_M2WriteOptions,
        ) -> i32;
        pub fn whiteout_m2_M2WriteOptions_set_emitSkeleton(
            self_: *mut whiteout_M2WriteOptions,
            value: i32,
        );
        pub fn whiteout_m2_M2WriteOptions_get_baseStem(
            self_: *mut whiteout_M2WriteOptions,
        ) -> RawCString;
        pub fn whiteout_m2_M2WriteOptions_set_baseStem(
            self_: *mut whiteout_M2WriteOptions,
            value: *const core::ffi::c_char,
        );
        // SerializeResult
        pub fn whiteout_m2_M2SerializeResult_new() -> *mut whiteout_M2SerializeResult;
        pub fn whiteout_m2_M2SerializeResult_delete(self_: *mut whiteout_M2SerializeResult);
        pub fn whiteout_m2_M2SerializeResult_get_m2Data_count(
            self_: *mut whiteout_M2SerializeResult,
        ) -> usize;
        pub fn whiteout_m2_M2SerializeResult_resize_m2Data(
            self_: *mut whiteout_M2SerializeResult,
            count: usize,
        );
        pub fn whiteout_m2_M2SerializeResult_get_m2Data_data(
            self_: *mut whiteout_M2SerializeResult,
        ) -> *const u8;
        pub fn whiteout_m2_M2SerializeResult_assign_m2Data(
            self_: *mut whiteout_M2SerializeResult,
            data: *const u8,
            count: usize,
        );
        // Writer
        pub fn whiteout_m2_M2Writer_new() -> *mut whiteout_M2Writer;
        pub fn whiteout_m2_M2Writer_new_options(
            _0: *mut core::ffi::c_void,
        ) -> *mut whiteout_M2Writer;
        pub fn whiteout_m2_M2Writer_delete(self_: *mut whiteout_M2Writer);
        pub fn whiteout_m2_M2Writer_write(
            self_: *mut whiteout_M2Writer,
            fs: *mut core::ffi::c_void,
            file_path: *const core::ffi::c_char,
            model: *mut whiteout_M2Model,
        );
        pub fn whiteout_m2_M2Writer_write_cascFs_model(
            self_: *mut whiteout_M2Writer,
            casc_fs: *mut core::ffi::c_void,
            model: *mut whiteout_M2Model,
        );
        pub fn whiteout_m2_M2Writer_write_model(
            self_: *mut whiteout_M2Writer,
            model: *mut whiteout_M2Model,
        ) -> *mut whiteout_M2SerializeResult;
        pub fn whiteout_m2_M2Writer_hasIssues(self_: *mut whiteout_M2Writer) -> i32;
        pub fn whiteout_m2_M2Writer_getIssues_count(self_: *mut whiteout_M2Writer) -> usize;
        pub fn whiteout_m2_M2Writer_getIssues_at(
            self_: *mut whiteout_M2Writer,
            index: usize,
        ) -> RawCString;
        // AnimationTrackVector3f
        pub fn whiteout_m2_M2AnimationTrackVector3f_new() -> *mut whiteout_M2AnimationTrackVector3f;
        pub fn whiteout_m2_M2AnimationTrackVector3f_delete(
            self_: *mut whiteout_M2AnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackVector3f,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackVector3f_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackVector3f,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackVector3f_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackVector3f,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackVector3f_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackVector3f_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_values_count(
            self_: *mut whiteout_M2AnimationTrackVector3f,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackVector3f_resize_values(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackVector3f_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
        ) -> *const f32;
        pub fn whiteout_m2_M2AnimationTrackVector3f_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackVector3f,
            outer: usize,
            data: *const f32,
            count: usize,
        );
        // AnimationTrackM2CompatQuaternion
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_new(
        ) -> *mut whiteout_M2AnimationTrackM2CompatQuaternion;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_delete(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_count(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_at(
            self_: *mut whiteout_M2AnimationTrackM2CompatQuaternion,
            outer: usize,
            inner: usize,
        ) -> *mut whiteout_M2CompatQuaternion;
        // AnimationTrackI16
        pub fn whiteout_m2_M2AnimationTrackI16_new() -> *mut whiteout_M2AnimationTrackI16;
        pub fn whiteout_m2_M2AnimationTrackI16_delete(self_: *mut whiteout_M2AnimationTrackI16);
        pub fn whiteout_m2_M2AnimationTrackI16_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackI16,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackI16_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackI16,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackI16,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackI16_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackI16,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackI16,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackI16_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackI16,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackI16_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_get_values_count(
            self_: *mut whiteout_M2AnimationTrackI16,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackI16_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackI16_resize_values(
            self_: *mut whiteout_M2AnimationTrackI16,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackI16_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
        ) -> *const i16;
        pub fn whiteout_m2_M2AnimationTrackI16_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackI16,
            outer: usize,
            data: *const i16,
            count: usize,
        );
        // AnimationTrackQuaternion
        pub fn whiteout_m2_M2AnimationTrackQuaternion_new(
        ) -> *mut whiteout_M2AnimationTrackQuaternion;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_delete(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_values_count(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_resize_values(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackQuaternion_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
        ) -> *const f32;
        pub fn whiteout_m2_M2AnimationTrackQuaternion_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackQuaternion,
            outer: usize,
            data: *const f32,
            count: usize,
        );
        // AnimationTrackF32
        pub fn whiteout_m2_M2AnimationTrackF32_new() -> *mut whiteout_M2AnimationTrackF32;
        pub fn whiteout_m2_M2AnimationTrackF32_delete(self_: *mut whiteout_M2AnimationTrackF32);
        pub fn whiteout_m2_M2AnimationTrackF32_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackF32,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackF32_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackF32,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackF32,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackF32_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackF32,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackF32,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackF32_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackF32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackF32_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_get_values_count(
            self_: *mut whiteout_M2AnimationTrackF32,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackF32_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackF32_resize_values(
            self_: *mut whiteout_M2AnimationTrackF32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackF32_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
        ) -> *const f32;
        pub fn whiteout_m2_M2AnimationTrackF32_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackF32,
            outer: usize,
            data: *const f32,
            count: usize,
        );
        // AnimationTrackU8
        pub fn whiteout_m2_M2AnimationTrackU8_new() -> *mut whiteout_M2AnimationTrackU8;
        pub fn whiteout_m2_M2AnimationTrackU8_delete(self_: *mut whiteout_M2AnimationTrackU8);
        pub fn whiteout_m2_M2AnimationTrackU8_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackU8,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackU8_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackU8,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackU8,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackU8_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackU8,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackU8,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU8_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackU8,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackU8_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_get_values_count(
            self_: *mut whiteout_M2AnimationTrackU8,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU8_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU8_resize_values(
            self_: *mut whiteout_M2AnimationTrackU8,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU8_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
        ) -> *const u8;
        pub fn whiteout_m2_M2AnimationTrackU8_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackU8,
            outer: usize,
            data: *const u8,
            count: usize,
        );
        // AnimationTrackM2CameraSpline
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_new(
        ) -> *mut whiteout_M2AnimationTrackM2CameraSpline;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_delete(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_count(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_at(
            self_: *mut whiteout_M2AnimationTrackM2CameraSpline,
            outer: usize,
            inner: usize,
        ) -> *mut whiteout_M2CameraSpline;
        // AnimationTrackU16
        pub fn whiteout_m2_M2AnimationTrackU16_new() -> *mut whiteout_M2AnimationTrackU16;
        pub fn whiteout_m2_M2AnimationTrackU16_delete(self_: *mut whiteout_M2AnimationTrackU16);
        pub fn whiteout_m2_M2AnimationTrackU16_get_interpolationType(
            self_: *mut whiteout_M2AnimationTrackU16,
        ) -> i32;
        pub fn whiteout_m2_M2AnimationTrackU16_set_interpolationType(
            self_: *mut whiteout_M2AnimationTrackU16,
            value: i32,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_get_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackU16,
        ) -> u16;
        pub fn whiteout_m2_M2AnimationTrackU16_set_globalSequenceId(
            self_: *mut whiteout_M2AnimationTrackU16,
            value: u16,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_get_timestamps_count(
            self_: *mut whiteout_M2AnimationTrackU16,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_count(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU16_resize_timestamps(
            self_: *mut whiteout_M2AnimationTrackU16,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_resize_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_data(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
        ) -> *const u32;
        pub fn whiteout_m2_M2AnimationTrackU16_assign_timestamps_inner(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_get_values_count(
            self_: *mut whiteout_M2AnimationTrackU16,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU16_get_values_inner_count(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
        ) -> usize;
        pub fn whiteout_m2_M2AnimationTrackU16_resize_values(
            self_: *mut whiteout_M2AnimationTrackU16,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_resize_values_inner(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
            count: usize,
        );
        pub fn whiteout_m2_M2AnimationTrackU16_get_values_inner_data(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
        ) -> *const u16;
        pub fn whiteout_m2_M2AnimationTrackU16_assign_values_inner(
            self_: *mut whiteout_M2AnimationTrackU16,
            outer: usize,
            data: *const u16,
            count: usize,
        );
        // ParticleAnimationTrackVector3f
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_new(
        ) -> *mut whiteout_M2ParticleAnimationTrackVector3f;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_delete(
            self_: *mut whiteout_M2ParticleAnimationTrackVector3f,
        );
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_count(
            self_: *mut whiteout_M2ParticleAnimationTrackVector3f,
        ) -> usize;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_resize_values(
            self_: *mut whiteout_M2ParticleAnimationTrackVector3f,
            count: usize,
        );
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_data(
            self_: *mut whiteout_M2ParticleAnimationTrackVector3f,
        ) -> *const f32;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector3f_assign_values(
            self_: *mut whiteout_M2ParticleAnimationTrackVector3f,
            data: *const f32,
            count: usize,
        );
        // ParticleAnimationTrackVector2f
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_new(
        ) -> *mut whiteout_M2ParticleAnimationTrackVector2f;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_delete(
            self_: *mut whiteout_M2ParticleAnimationTrackVector2f,
        );
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_count(
            self_: *mut whiteout_M2ParticleAnimationTrackVector2f,
        ) -> usize;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_resize_values(
            self_: *mut whiteout_M2ParticleAnimationTrackVector2f,
            count: usize,
        );
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_data(
            self_: *mut whiteout_M2ParticleAnimationTrackVector2f,
        ) -> *const f32;
        pub fn whiteout_m2_M2ParticleAnimationTrackVector2f_assign_values(
            self_: *mut whiteout_M2ParticleAnimationTrackVector2f,
            data: *const f32,
            count: usize,
        );
    }
}