whiteout/

m3.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 m3 --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};

/// Vertex format flags determining vertex buffer layout
///
/// These bitmask flags control the per-vertex data layout in the U8__ vertex blob. The vertex stride is: 24 + (hasColor ? 4 : 0) + (numUVs * 4) + 4 bytes.
/// Bit flags. Combine with `|`, test with [`VertexFormatFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct VertexFormatFlag(pub i32);

impl VertexFormatFlag {
    pub const NONE: Self = Self(0);
    /// Bit 10 (1-based): Has vertex color (adds 4 bytes)
    pub const VERTEX_COLOR: Self = Self(512);
    /// Bit 18 (1-based): Has UV layer 1 (adds 4 bytes)
    pub const UV_1: Self = Self(131072);
    /// Bit 19 (1-based): Has UV layer 2 (adds 4 bytes)
    pub const UV_2: Self = Self(262144);
    /// Bit 20 (1-based): Has UV layer 3 (adds 4 bytes)
    pub const UV_3: Self = Self(524288);
    /// Bit 21 (1-based): Has UV layer 4 (adds 4 bytes)
    pub const UV_4: Self = Self(1048576);
    /// Bit 30 (1-based): Has UV layer 5 (adds 4 bytes)
    pub const UV_5: Self = Self(536870912);

    #[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 VertexFormatFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Identifies which material array a MATM entry references
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MaterialType {
    /// MAT_ — Standard material
    Standard = 1,
    /// DIS_ — Displacement material
    Displacement = 2,
    /// CMP_ — Composite material
    Composite = 3,
    /// TER_ — Terrain material
    Terrain = 4,
    /// VOL_ — Volume material
    Volume = 5,
    /// VON_ — Volume noise material
    VolumeNoise = 6,
    /// CREP — Creep material
    Creep = 7,
    /// HAI_ — Hair material (defunct)
    Hair = 8,
    /// STBM — Splat terrain bake material
    SplatTerrainBake = 9,
    /// REF_ — Reflection material
    Reflection = 10,
    /// LFLR — Lens flare material
    LensFlare = 11,
    /// MADD — Data-driven material; what every other type is converted into at load
    DataDriven = 12,
}

impl TryFrom<i32> for MaterialType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            1 => Ok(MaterialType::Standard),
            2 => Ok(MaterialType::Displacement),
            3 => Ok(MaterialType::Composite),
            4 => Ok(MaterialType::Terrain),
            5 => Ok(MaterialType::Volume),
            6 => Ok(MaterialType::VolumeNoise),
            7 => Ok(MaterialType::Creep),
            8 => Ok(MaterialType::Hair),
            9 => Ok(MaterialType::SplatTerrainBake),
            10 => Ok(MaterialType::Reflection),
            11 => Ok(MaterialType::LensFlare),
            12 => Ok(MaterialType::DataDriven),
            other => Err(crate::Error::UnknownEnum {
                name: "MaterialType",
                value: other,
            }),
        }
    }
}

/// Light source type (LITE)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum LightType {
    /// Point light (omnidirectional)
    Omni = 0,
    /// Spot light (cone)
    Spot = 1,
    /// Directional light (infinite distance)
    Directional = 2,
}

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

/// Physics collision shape type (PHSH)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PhysicsShapeType {
    /// Box (half-extents in shapeDimensions)
    Box = 0,
    /// Sphere (radius in shapeDimensions.x)
    Sphere = 1,
    /// Capsule (radius + height)
    Capsule = 2,
    /// Cylinder (radius + height)
    Cylinder = 3,
    /// Convex hull (vertex/half-edge data)
    ConvexHull = 4,
    /// Triangle mesh (face/edge/normal data)
    Mesh = 5,
}

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::Sphere),
            2 => Ok(PhysicsShapeType::Capsule),
            3 => Ok(PhysicsShapeType::Cylinder),
            4 => Ok(PhysicsShapeType::ConvexHull),
            5 => Ok(PhysicsShapeType::Mesh),
            other => Err(crate::Error::UnknownEnum {
                name: "PhysicsShapeType",
                value: other,
            }),
        }
    }
}

/// Hit-test shape type (SSGS / ATVL), same semantics as PhysicsShapeType but u32
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum HitTestShapeType {
    Box = 0,
    Sphere = 1,
    Capsule = 2,
    Cylinder = 3,
    Mesh = 4,
}

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

/// Particle / ribbon emitter shape (PAR_ / RIB_)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum EmitterShape {
    /// Emit from a single point
    Point = 0,
    /// Emit from a rectangular plane
    Plane = 1,
    /// Emit from a sphere surface/volume
    Sphere = 2,
    /// Emit from a box volume
    Box = 3,
    /// Emit from a cylinder
    Cylinder = 4,
    /// Emit from a disc
    Disc = 5,
    /// Emit from a spline path, splineLineData
    Spline = 6,
    /// Emit from mesh surface, mesh region indices in shapeRegions
    Mesh = 7,
}

impl TryFrom<i32> for EmitterShape {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(EmitterShape::Point),
            1 => Ok(EmitterShape::Plane),
            2 => Ok(EmitterShape::Sphere),
            3 => Ok(EmitterShape::Box),
            4 => Ok(EmitterShape::Cylinder),
            5 => Ok(EmitterShape::Disc),
            6 => Ok(EmitterShape::Spline),
            7 => Ok(EmitterShape::Mesh),
            other => Err(crate::Error::UnknownEnum {
                name: "EmitterShape",
                value: other,
            }),
        }
    }
}

/// Particle visual / billboard type (maps to b_iInstanceType in Particle.fx)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ParticleInstanceType {
    /// Camera-facing billboard quad
    Billboard = 0,
    /// Velocity-stretched quad
    Tail = 1,
    /// Quad oriented along instantaneous velocity
    FaceTravelDir = 2,
    /// Quad oriented along a fixed world direction
    FaceWorldDir = 3,
    /// Billboard locked to a single rotation axis
    SingleAxis = 4,
    /// Quad projected onto terrain normal
    TerrainOriented = 5,
    /// Terrain-oriented + velocity-stretched
    TerrainDirOriented = 6,
    /// Quad uses the emitter bone's orientation
    EmitterOriented = 7,
    /// Quad oriented by physics simulation
    PhysicsOriented = 8,
    /// Stretch between spawn origin and current position
    Pinned = 9,
    /// Like Tail but offset by one tail-length
    Trail = 10,
}

impl TryFrom<i32> for ParticleInstanceType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(ParticleInstanceType::Billboard),
            1 => Ok(ParticleInstanceType::Tail),
            2 => Ok(ParticleInstanceType::FaceTravelDir),
            3 => Ok(ParticleInstanceType::FaceWorldDir),
            4 => Ok(ParticleInstanceType::SingleAxis),
            5 => Ok(ParticleInstanceType::TerrainOriented),
            6 => Ok(ParticleInstanceType::TerrainDirOriented),
            7 => Ok(ParticleInstanceType::EmitterOriented),
            8 => Ok(ParticleInstanceType::PhysicsOriented),
            9 => Ok(ParticleInstanceType::Pinned),
            10 => Ok(ParticleInstanceType::Trail),
            other => Err(crate::Error::UnknownEnum {
                name: "ParticleInstanceType",
                value: other,
            }),
        }
    }
}

/// Force influence type (FOR_)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ForceType {
    /// Radial force (outward from center)
    Radial = 0,
    /// Wind force (directional)
    Wind = 1,
    /// Explosion force (impulse)
    Explosion = 2,
}

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

/// Influence volume shape for a force (FOR_)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ForceShape {
    /// Spherical influence volume
    Sphere = 0,
    /// Cylindrical influence volume
    Cylinder = 1,
    /// Box influence volume
    Box = 2,
    /// Hemispherical influence volume
    Hemisphere = 3,
}

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

/// Ribbon cross-section type (maps to b_iRibbonType in Ribbon.fx)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RibbonType {
    /// Camera-facing ribbon strip
    Billboard = 0,
    /// Flat/planar ribbon strip
    Planar = 1,
    /// Cylindrical cross-section
    Cylinder = 2,
    /// Star-shaped cross-section
    Star = 3,
}

impl TryFrom<i32> for RibbonType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(RibbonType::Billboard),
            1 => Ok(RibbonType::Planar),
            2 => Ok(RibbonType::Cylinder),
            3 => Ok(RibbonType::Star),
            other => Err(crate::Error::UnknownEnum {
                name: "RibbonType",
                value: other,
            }),
        }
    }
}

/// Projector / decal projection type (PROJ)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ProjectionType {
    /// Orthographic projection
    Orthographic = 0,
    /// Perspective projection
    Perspective = 1,
}

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

/// Volume shape type (VOL_ / VON_)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VolumeType {
    Box = 0,
    Sphere = 1,
    Capsule = 2,
}

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

/// Interpolation mode for particle/ribbon smoothing curves
///
/// Maps to RibbonParticleCommon.fx constants. Used by PAR_ colorSmoothing / sizeSmoothing / rotationSmoothing and RIB_ sizeSmoothing / colorSmoothing.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum InterpolationMode {
    /// ITERPOLATION_LINEAR
    Linear = 0,
    /// ITERPOLATION_LINEAR_SMOOTH
    LinearSmooth = 1,
    /// ITERPOLATION_BEZIER
    Bezier = 2,
    /// ITERPOLATION_LINEAR_WITH_HOLD
    LinearWithHold = 3,
    /// ITERPOLATION_BEZIER_WITH_HOLD
    BezierWithHold = 4,
}

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

/// Model-wide flags (MODL.flags) — tangents, FOW, instancing, etc.
/// Bit flags. Combine with `|`, test with [`ModelFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct ModelFlag(pub i32);

impl ModelFlag {
    pub const NONE: Self = Self(0);
    /// Tangents computed
    pub const TANGENTS: Self = Self(1);
    /// Bone transforms fixed
    pub const BONES_FIXED: Self = Self(2);
    /// UV densities computed
    pub const UV_DENSITIES_COMPUTED: Self = Self(4);
    /// Uses relative bounds
    pub const RELATIVE_BOUNDS: Self = Self(8);
    /// Section bounds fixed
    pub const SECTION_BOUNDS_FIXED: Self = Self(16);
    /// Track sets computed
    pub const TRACK_SETS_COMPUTED: Self = Self(32);
    /// Track collection sorted
    pub const TRACK_COLLECTION_SORTED: Self = Self(64);
    /// Model accepts splats
    pub const ACCEPTS_SPLATS: Self = Self(128);
    /// Animated base flag valid
    pub const TRACK_ANIMATED_BASE_FLAG_VALID: Self = Self(2048);
    /// File marked dirty
    pub const FILE_DIRTY: Self = Self(4096);
    /// FOW: do not tint
    pub const FOW_DO_NOT_USE_TINT: Self = Self(16384);
    /// Uses instanced vertex buffer
    pub const INSTANCED_VB: Self = Self(32768);
    /// Force sampled FOW
    pub const FORCE_SAMPLED_FOW: Self = Self(65536);
    /// Instanced model
    pub const INSTANCED_MODEL: Self = Self(131072);
    /// Never use FOW
    pub const NEVER_USE_FOW: Self = Self(262144);
    /// Bone animated flags solved
    pub const BONE_ANIMATED_FLAG_SOLVED: Self = Self(524288);
    /// Allow local light shadows
    pub const ALLOW_LOCAL_LIGHT_SHADOWS: Self = Self(1048576);
    /// Avoid sampled FOW
    pub const AVOID_SAMPLED_FOW: 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 ModelFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Sequence playback flags (SEQS.flags)
/// 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);
    /// Sequence does not loop
    pub const NOT_LOOPING: Self = Self(1);
    /// Always plays globally
    pub const ALWAYS_GLOBAL: Self = Self(2);
    /// Unknown
    pub const UNKNOWN_0X_4: Self = Self(4);
    /// Global playback in editor
    pub const GLOBAL_IN_PREVIEWER: Self = Self(8);

    #[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)
    }
}

/// BBSC.billboardType — which axes a billboarded bone may turn about.
///
/// Recovered from `CBBSolver::ApplyBillboard` (SC2 `0x1027F1F30`). The aim direction points *away* from the eye, so "aims at" below means the named axis lies along it and its negation points back at the camera.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum BillboardType {
    /// Turns about world X; local +Y aims along the direction
    LockWorldX = 0,
    /// Turns about world Y; local +X aims (Y is the locked one)
    LockWorldY = 1,
    /// Turns about world Z; local +Y aims. The upright poster
    LockWorldZ = 2,
    /// Turns about the bone's own world X; local +Z faces the camera
    LockBoneX = 3,
    /// Parsed and instantiated, never applied
    Disabled = 4,
    /// The bone's own world Y becomes local Z; local +Y faces the camera
    LockBoneY = 5,
    /// Free; local +Y aims, and the camera's up axis sets the roll
    Full = 6,
}

impl TryFrom<i32> for BillboardType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(BillboardType::LockWorldX),
            1 => Ok(BillboardType::LockWorldY),
            2 => Ok(BillboardType::LockWorldZ),
            3 => Ok(BillboardType::LockBoneX),
            4 => Ok(BillboardType::Disabled),
            5 => Ok(BillboardType::LockBoneY),
            6 => Ok(BillboardType::Full),
            other => Err(crate::Error::UnknownEnum {
                name: "BillboardType",
                value: other,
            }),
        }
    }
}

/// Bone flags (BONE.flags) — inheritance, IK, skin
/// 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);
    /// Inherit parent translation
    pub const INHERIT_TRANSLATION: Self = Self(1);
    /// Inherit parent scale
    pub const INHERIT_SCALE: Self = Self(2);
    /// Inherit parent rotation
    pub const INHERIT_ROTATION: Self = Self(4);
    /// Unused: set on no bone in 51469 corpus files
    pub const BILLBOARD_1: Self = Self(16);
    /// Unused: likewise. Billboarding comes from BBSC
    pub const BILLBOARD_2: Self = Self(64);
    /// 2D projection mode
    pub const PROJECT_2D: Self = Self(256);
    /// Has animation data
    pub const ANIMATED: Self = Self(512);
    /// IK bone
    pub const INVERSE_KINEMATICS: Self = Self(1024);
    /// Affects mesh skin
    pub const SKINNED: Self = Self(2048);
    /// Real bone (not helper)
    pub const REAL: Self = Self(8192);
    /// Primary batch bone
    pub const BATCH_1: Self = Self(16384);
    /// Descendant of batch1 bone
    pub const BATCH_2: Self = Self(32768);

    #[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)
    }
}

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

impl RegionFlag {
    pub const NONE: Self = Self(0);
    /// Region is hidden
    pub const HIDDEN: Self = Self(1);
    /// Placeholder region
    pub const PLACEHOLDER: Self = Self(2);
    /// Cloth-simulated
    pub const CLOTH_SIMULATED: Self = Self(4);
    /// Cloth-influenced
    pub const CLOTH_INFLUENCED: Self = Self(8);

    #[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 RegionFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Additional standard-material flags (MAT_.additionalFlags)
/// Bit flags. Combine with `|`, test with [`MaterialAdditionalFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct MaterialAdditionalFlag(pub i32);

impl MaterialAdditionalFlag {
    pub const NONE: Self = Self(0);
    /// Enable depth blend falloff
    pub const DEPTH_BLEND_FALLOFF: Self = Self(1);
    /// Uses vertex color
    pub const VERTEX_COLOR: Self = Self(4);
    /// Uses vertex alpha
    pub const VERTEX_ALPHA: Self = Self(8);

    #[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 MaterialAdditionalFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Standard material rendering flags (MAT_.flags)
/// 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);
    /// Enable vertex color
    pub const VERTEX_COLOR: Self = Self(1);
    /// Enable vertex alpha
    pub const VERTEX_ALPHA: Self = Self(2);
    /// Blend the normal-blend layers by factors 0-3 (v19+)
    pub const NORMAL_BLEND: Self = Self(4);
    /// Two-sided rendering
    pub const TWO_SIDED: Self = Self(8);
    /// Unlit / unshaded
    pub const UNSHADED: Self = Self(16);
    /// Does not cast shadows
    pub const NO_SHADOWS_CAST: Self = Self(32);
    /// Excluded from hit testing
    pub const NO_HIT_TEST: Self = Self(64);
    /// Does not receive shadows
    pub const NO_SHADOWS_RECEIVE: Self = Self(128);
    /// Z-fill pre-pass
    pub const DEPTH_PREPASS: Self = Self(256);
    /// Terrain HDR mode
    pub const TERRAIN_HDR: Self = Self(512);
    /// Simulate roughness
    pub const SIMULATE_ROUGHNESS: Self = Self(2048);
    /// Pixel forward lighting
    pub const PIXEL_FORWARD_LIGHTING: Self = Self(4096);
    /// Not affected by fog
    pub const UNFOGGED: Self = Self(8192);
    /// Transparent shadows
    pub const TRANSPARENT_SHADOWS: Self = Self(16384);
    /// Decal lighting mode
    pub const DECAL_LIGHTING: Self = Self(32768);
    /// Transparent depth effects
    pub const TRANSPARENT_DEPTH_EFFECTS: Self = Self(65536);
    /// Transparent local lights
    pub const TRANSPARENT_LOCAL_LIGHTS: Self = Self(131072);
    /// Disable soft blending
    pub const DISABLE_SOFT: Self = Self(262144);
    /// Double Lambert shading
    pub const DOUBLE_LAMBERT: Self = Self(524288);
    /// Hair layer sorting
    pub const HAIR_LAYER_SORTING: Self = Self(1048576);
    /// Accept splat projections
    pub const ACCEPT_SPLATS: Self = Self(2097152);
    /// Decal low LOD required
    pub const DECAL_LOW_REQUIRED: Self = Self(4194304);
    /// Emissive low LOD required
    pub const EMIS_LOW_REQUIRED: Self = Self(8388608);
    /// Specular low LOD required
    pub const SPEC_LOW_REQUIRED: Self = Self(16777216);
    /// Accept splats only
    pub const ACCEPT_SPLATS_ONLY: Self = Self(33554432);
    /// Background object
    pub const BACKGROUND_OBJECT: Self = Self(67108864);
    /// Second normal blend, by factors 4-7 (v19+)
    pub const NORMAL_BLEND_2: Self = Self(134217728);
    /// Depth prepass low LOD
    pub const DEPTH_PREPASS_LOW_REQUIRED: Self = Self(268435456);
    /// Disable highlighting
    pub const NO_HIGHLIGHTING: Self = Self(536870912);
    /// Clamp output
    pub const CLAMP_OUTPUT: Self = Self(1073741824);
    /// Geometry visible (v17+)
    pub const GEOMETRY_VISIBLE: 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 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)
    }
}

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

impl TextureLayerFlag {
    pub const NONE: Self = Self(0);
    /// Wrap texture in U
    pub const UV_WRAP_X: Self = Self(4);
    /// Wrap texture in V
    pub const UV_WRAP_Y: Self = Self(8);
    /// Invert color
    pub const COLOR_INVERT: Self = Self(16);
    /// Clamp to `[0,1]`
    pub const COLOR_CLAMP: Self = Self(32);
    /// Additive blending
    pub const COLOR_ADD: Self = Self(64);
    /// Multiplicative blending
    pub const COLOR_MULTIPLY: Self = Self(128);
    /// Flipbook UVs for particles
    pub const PARTICLE_UV_FLIPBOOK: Self = Self(256);
    /// Video texture
    pub const VIDEO: Self = Self(512);
    /// Solid color (no texture)
    pub const COLOR: Self = Self(1024);
    /// Override texture source
    pub const REPLACE_TEXTURE_SOURCE: Self = Self(2048);
    /// Fresnel-based UV transform
    pub const FRESNEL_TRANSFORM: Self = Self(16384);
    /// Normalize fresnel values
    pub const FRESNEL_NORMALIZE: Self = Self(32768);

    #[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 TextureLayerFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Blend mode for materials (MAT_.blendMode, VOL_.blendMode)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum BlendMode {
    /// Fully opaque
    Opaque = 0,
    /// Standard alpha blending
    AlphaBlend = 1,
    /// Additive blending
    Add = 2,
    /// Alpha-modulated additive
    AlphaAdd = 3,
    /// Multiplicative blending
    Mod = 4,
    /// Double multiplicative
    Mod2x = 5,
}

impl TryFrom<i32> for BlendMode {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(BlendMode::Opaque),
            1 => Ok(BlendMode::AlphaBlend),
            2 => Ok(BlendMode::Add),
            3 => Ok(BlendMode::AlphaAdd),
            4 => Ok(BlendMode::Mod),
            5 => Ok(BlendMode::Mod2x),
            other => Err(crate::Error::UnknownEnum {
                name: "BlendMode",
                value: other,
            }),
        }
    }
}

/// Material rendering class (MAT_.materialClass)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MaterialClass {
    /// Unit/character material
    Unit = 0,
    /// Building/structure material
    Building = 1,
    /// Doodad/prop material
    Doodad = 2,
    /// Special effect material
    SpecialFX = 3,
}

impl TryFrom<i32> for MaterialClass {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(MaterialClass::Unit),
            1 => Ok(MaterialClass::Building),
            2 => Ok(MaterialClass::Doodad),
            3 => Ok(MaterialClass::SpecialFX),
            other => Err(crate::Error::UnknownEnum {
                name: "MaterialClass",
                value: other,
            }),
        }
    }
}

/// Layer blend operation (MAT_.layerBlendMode, emissiveBlendMode)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum LayerBlendOp {
    /// Multiply: base * layer
    Mod = 0,
    /// Double multiply: base * layer * 2
    Mod2x = 1,
    /// Add: base + layer
    Add = 2,
    /// Linear interpolate by layer alpha
    Lerp = 3,
    /// Team color emissive add
    TeamColorEmissiveAdd = 4,
    /// Team color diffuse add
    TeamColorDiffuseAdd = 5,
    /// Add ignoring alpha channel
    AddNoAlpha = 6,
}

impl TryFrom<i32> for LayerBlendOp {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(LayerBlendOp::Mod),
            1 => Ok(LayerBlendOp::Mod2x),
            2 => Ok(LayerBlendOp::Add),
            3 => Ok(LayerBlendOp::Lerp),
            4 => Ok(LayerBlendOp::TeamColorEmissiveAdd),
            5 => Ok(LayerBlendOp::TeamColorDiffuseAdd),
            6 => Ok(LayerBlendOp::AddNoAlpha),
            other => Err(crate::Error::UnknownEnum {
                name: "LayerBlendOp",
                value: other,
            }),
        }
    }
}

/// UV mapping source / projection mode (LAYR.uvMapping)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum UVMappingMode {
    /// UV coordinate set 0
    ExplicitUV0 = 0,
    /// UV coordinate set 1
    ExplicitUV1 = 1,
    /// Cubic environment reflection
    ReflectCubicEnvio = 2,
    /// Spherical environment reflection
    ReflectSphericalEnvio = 3,
    /// Planar local UVs (Z plane)
    PlanarLocalZ = 4,
    /// Planar world UVs (Z plane)
    PlanarWorldZ = 5,
    /// Particle flipbook UVs
    ParticleFlipbook = 6,
    /// Cubic environment mapping
    CubicEnvio = 7,
    /// Spherical environment mapping
    SphericalEnvio = 8,
    /// UV coordinate set 2
    ExplicitUV2 = 9,
    /// UV coordinate set 3
    ExplicitUV3 = 10,
    /// Planar local UVs (X plane)
    PlanarLocalX = 11,
    /// Planar local UVs (Y plane)
    PlanarLocalY = 12,
    /// Planar world UVs (X plane)
    PlanarWorldX = 13,
    /// Planar world UVs (Y plane)
    PlanarWorldY = 14,
    /// Screen-space UVs
    ScreenSpace = 15,
    /// Tri-planar blending (local space)
    TriPlanarLocal = 16,
    /// Tri-planar blending (world space)
    TriPlanarWorld = 17,
    /// Tri-planar world with local Z
    TriPlanarWorldLocalZ = 18,
}

impl TryFrom<i32> for UVMappingMode {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(UVMappingMode::ExplicitUV0),
            1 => Ok(UVMappingMode::ExplicitUV1),
            2 => Ok(UVMappingMode::ReflectCubicEnvio),
            3 => Ok(UVMappingMode::ReflectSphericalEnvio),
            4 => Ok(UVMappingMode::PlanarLocalZ),
            5 => Ok(UVMappingMode::PlanarWorldZ),
            6 => Ok(UVMappingMode::ParticleFlipbook),
            7 => Ok(UVMappingMode::CubicEnvio),
            8 => Ok(UVMappingMode::SphericalEnvio),
            9 => Ok(UVMappingMode::ExplicitUV2),
            10 => Ok(UVMappingMode::ExplicitUV3),
            11 => Ok(UVMappingMode::PlanarLocalX),
            12 => Ok(UVMappingMode::PlanarLocalY),
            13 => Ok(UVMappingMode::PlanarWorldX),
            14 => Ok(UVMappingMode::PlanarWorldY),
            15 => Ok(UVMappingMode::ScreenSpace),
            16 => Ok(UVMappingMode::TriPlanarLocal),
            17 => Ok(UVMappingMode::TriPlanarWorld),
            18 => Ok(UVMappingMode::TriPlanarWorldLocalZ),
            other => Err(crate::Error::UnknownEnum {
                name: "UVMappingMode",
                value: other,
            }),
        }
    }
}

/// Color channel selection (LAYR.colorType)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ColorChannelSelect {
    /// Use RGB channels (alpha forced to 1)
    RGB = 0,
    /// Use all RGBA channels
    RGBA = 1,
    /// Use alpha channel only (splat to all)
    Alpha = 2,
    /// Use red channel only (splat to all)
    Red = 3,
    /// Use green channel only (splat to all)
    Green = 4,
    /// Use blue channel only (splat to all)
    Blue = 5,
}

impl TryFrom<i32> for ColorChannelSelect {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(ColorChannelSelect::RGB),
            1 => Ok(ColorChannelSelect::RGBA),
            2 => Ok(ColorChannelSelect::Alpha),
            3 => Ok(ColorChannelSelect::Red),
            4 => Ok(ColorChannelSelect::Green),
            5 => Ok(ColorChannelSelect::Blue),
            other => Err(crate::Error::UnknownEnum {
                name: "ColorChannelSelect",
                value: other,
            }),
        }
    }
}

/// Specular mode (MAT_.specularMode)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SpecularMode {
    /// Use RGB channels for specularity
    RGB = 0,
    /// Use alpha channel only
    AlphaOnly = 1,
}

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

/// Fresnel effect mode (LAYR.fresnelMode)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FresnelMode {
    /// No fresnel effect
    None = 0,
    /// Standard fresnel (edge glow)
    Standard = 1,
    /// Inverted fresnel (center glow)
    Inverted = 2,
}

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

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

impl ReflectionMaterialFlag {
    pub const NONE: Self = Self(0);
    /// Use reflection map
    pub const USE_REFLECTION_MAP: Self = Self(1);
    /// Use displacement map
    pub const USE_DISPLACEMENT_MAP: Self = Self(2);
    /// Render in transparent pass
    pub const RENDER_IN_TRANSPARENT_PASS: Self = Self(4);
    /// Enable blurring
    pub const BLURRING: Self = Self(8);
    /// Use blur map
    pub const USE_BLUR_MAP: Self = Self(16);

    #[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 ReflectionMaterialFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Volume noise material flags (VON_.flags)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VolumeNoiseMaterialFlag {
    None = 0,
    /// Draw in separate pass after transparency
    DrawAfterTransparency = 1,
}

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

/// Volume density falloff type (VOL_.falloffType, VON_.falloffType)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VolumeFalloffType {
    /// Linear density falloff
    Linear = 0,
    /// Exponential density falloff
    Exponential = 1,
}

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

/// Volume noise camera position mode (VON_.drawTransparency)
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VolumeNoiseCameraMode {
    /// Camera is outside the volume
    Outside = 0,
    /// Camera is inside the volume
    Inside = 1,
}

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

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

impl LightFlag {
    pub const NONE: Self = Self(0);
    /// Casts shadows
    pub const SHADOWS: Self = Self(1);
    /// Specular component
    pub const SPECULAR: Self = Self(2);
    /// AO influence
    pub const AMBIENT_OCCLUSION: Self = Self(4);
    /// Lights opaque objects
    pub const LIGHT_OPAQUE: Self = Self(8);
    /// Lights transparent objects
    pub const LIGHT_TRANSPARENT: Self = Self(16);
    /// Uses team color
    pub const TEAM_COLOR: Self = Self(32);

    #[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 LightFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Particle emitter main flags (PAR_.flags)
/// 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);
    /// Sort by distance
    pub const SORT: Self = Self(1);
    /// Collide with terrain
    pub const COLLIDE_TERRAIN: Self = Self(2);
    /// Collide with objects
    pub const COLLIDE_OBJECTS: Self = Self(4);
    /// Emit on collision
    pub const COLLIDE_EMIT: Self = Self(8);
    /// Emit from shape cutout
    pub const EMIT_SHAPE_CUTOUT: Self = Self(16);
    /// Inherit emission parameters
    pub const INHERIT_EMIT_PARAMS: Self = Self(32);
    /// Inherit parent velocity
    pub const INHERIT_PARENT_VELOCITY: Self = Self(64);
    /// Sort by height
    pub const SORT_HEIGHT: Self = Self(128);
    /// Reverse sort order
    pub const SORT_REVERSE: Self = Self(256);
    /// Legacy rotation smoothing
    pub const OLD_ROTATION_SMOOTH: Self = Self(512);
    /// Legacy rotation bezier
    pub const OLD_ROTATION_BEZIER: Self = Self(1024);
    /// Legacy size smoothing
    pub const OLD_SIZE_SMOOTH: Self = Self(2048);
    /// Legacy size bezier
    pub const OLD_SIZE_BEZIER: Self = Self(4096);
    /// Legacy color smoothing
    pub const OLD_COLOR_SMOOTH: Self = Self(8192);
    /// Legacy color bezier
    pub const OLD_COLOR_BEZIER: Self = Self(16384);
    /// Lit particles → lit pixel-shader variant
    pub const LIT_PARTS: Self = Self(32768);
    /// Random flipbook start → shader b_randomFlipBookStart
    pub const RANDOM_FLIPBOOK_START: Self = Self(65536);
    /// Multiply gravity by mass
    pub const MULTIPLY_GRAVITY_BY_MASS: Self = Self(131072);
    /// Clamp tail length → shader b_clampedTailLength (Tail/Trail, not Pinned)
    pub const CLAMP_TAIL_LENGTH: Self = Self(262144);
    /// Spawn trailing particles (also forces b_useProceduralPosition)
    pub const SPAWN_TRAILING_PARTICLES: Self = Self(524288);
    /// Fix tail length on creation → shader b_fixedTailLength
    pub const FIX_TAIL_LENGTH_ON_CREATION: Self = Self(1048576);
    /// Use vertex alpha
    pub const USE_VERTEX_ALPHA: Self = Self(2097152);
    /// Use model particles (also forces b_useProceduralPosition)
    pub const MODEL_PARTICLES: Self = Self(4194304);
    /// Swap Y/Z on model particles
    pub const SWAP_YZ_ON_MODEL_PARTICLES: Self = Self(8388608);
    /// Scale time by parent
    pub const SCALE_TIME_BY_PARENT: Self = Self(16777216);
    /// Use local time
    pub const USE_LOCAL_TIME: Self = Self(33554432);
    /// Simulate on initialization
    pub const SIMULATE_INIT: Self = Self(67108864);
    /// Copy emitter
    pub const COPY: Self = Self(134217728);
    /// Part of the b_useProceduralPosition trigger mask (0x10480003)
    pub const REQUIRES_GPU_SIM: Self = Self(268435456);
    /// Toggles a particle shader permutation (role TBD)
    pub const SHADER_PERM_30: Self = Self(1073741824);
    /// Forces GPU procedural-position path (b_useProceduralPosition)
    pub const FORCE_PROCEDURAL_POSITION: 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)
    }
}

/// Particle emitter additional flags (PAR_.additionalFlags, v17+)
/// Bit flags. Combine with `|`, test with [`ParticleAdditionalFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct ParticleAdditionalFlag(pub i32);

impl ParticleAdditionalFlag {
    pub const NONE: Self = Self(0);
    /// Randomize emission speed
    pub const EMIT_SPEED_RANDOMIZE: Self = Self(1);
    /// Randomize lifespan
    pub const LIFESPAN_RANDOMIZE: Self = Self(2);
    /// Randomize mass
    pub const MASS_RANDOMIZE: Self = Self(4);
    /// World-space coordinates
    pub const WORLD_SPACE: Self = Self(8);

    #[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 ParticleAdditionalFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Particle rotation flags (PAR_.rotationFlags, v18+)
/// Bit flags. Combine with `|`, test with [`ParticleRotationFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct ParticleRotationFlag(pub i32);

impl ParticleRotationFlag {
    pub const NONE: Self = Self(0);
    /// Relative rotation; the SC2 upgrade sets it from rotationRandomEnable (v≤18)
    pub const RELATIVE: Self = Self(2);
    /// Always set
    pub const ALWAYS_SET: Self = Self(4);
    /// Force-set by the SC2 version upgrade for all v≤20 emitters (role TBD)
    pub const UNKNOWN_6: Self = Self(64);
    /// Set by the SC2 upgrade for remapped Billboard model particles (role TBD)
    pub const UNKNOWN_7: Self = Self(128);

    #[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 ParticleRotationFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

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

impl RibbonFlag {
    pub const NONE: Self = Self(0);
    /// Collide with terrain
    pub const COLLIDE_TERRAIN: Self = Self(2);
    /// Collide with objects
    pub const COLLIDE_OBJECTS: Self = Self(4);
    /// Fade edges
    pub const EDGE_FALLOFF: Self = Self(8);
    /// Inherit parent velocity
    pub const INHERIT_PARENT_VELOCITY: Self = Self(16);
    /// Smooth size
    pub const SMOOTH_SIZE: Self = Self(32);
    /// Bezier smooth size
    pub const BEZIER_SMOOTH_SIZE: Self = Self(64);
    /// Use vertex alpha
    pub const USE_VERTEX_ALPHA: Self = Self(128);
    /// Scale time by parent
    pub const SCALE_TIME_BY_PARENT: Self = Self(256);
    /// Force CPU simulation
    pub const FORCE_CPU_SIM: Self = Self(512);
    /// Use local time
    pub const LOCAL_TIME: Self = Self(1024);
    /// Simulate on init
    pub const SIMULATE_INIT: Self = Self(2048);
    /// Use length and time
    pub const USE_LENGTH_AND_TIME: Self = Self(4096);
    /// Accurate GPU tangents
    pub const ACCURATE_GPU_TANGENTS: Self = Self(8192);
    /// Derive yaw from speed
    pub const YAW_FROM_SPEED: Self = Self(16384);
    /// Use locator node
    pub const USE_LOCATOR: Self = Self(32768);

    #[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 RibbonFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Ribbon emitter additional flags (RIB_.flags2, v8+)
/// Bit flags. Combine with `|`, test with [`RibbonAdditionalFlag::contains`].
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct RibbonAdditionalFlag(pub i32);

impl RibbonAdditionalFlag {
    pub const NONE: Self = Self(0);
    /// Randomize emission speed
    pub const SPEED_RANDOMIZE: Self = Self(1);
    /// Randomize lifespan
    pub const LIFESPAN_RANDOMIZE: Self = Self(2);
    /// Randomize mass
    pub const MASS_RANDOMIZE: Self = Self(4);
    /// World-space coordinates
    pub const WORLD_SPACE: Self = Self(8);

    #[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 RibbonAdditionalFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

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

impl ProjectorFlag {
    pub const NONE: Self = Self(0);
    /// Static position
    pub const STATIC: Self = Self(1);
    /// Unknown
    pub const UNKNOWN_FLAG_0X_2: Self = Self(2);
    /// Unknown
    pub const UNKNOWN_FLAG_0X_4: Self = Self(4);
    /// Unknown
    pub const UNKNOWN_FLAG_0X_8: Self = Self(8);

    #[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 ProjectorFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

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

impl ForceFlag {
    pub const NONE: Self = Self(0);
    /// Distance falloff
    pub const FALLOFF: Self = Self(1);
    /// Height gradient
    pub const HEIGHT_GRADIENT: Self = Self(2);
    /// Unbounded range
    pub const UNBOUNDED: Self = Self(4);

    #[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 ForceFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

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

impl RigidBodyFlag {
    pub const NONE: Self = Self(0);
    /// Can collide
    pub const COLLIDABLE: Self = Self(1);
    /// Walkable surface
    pub const WALKABLE: Self = Self(2);
    /// Can be stacked
    pub const STACKABLE: Self = Self(4);
    /// Simulate collisions
    pub const SIMULATE_COLLISION: Self = Self(8);
    /// Ignore local bodies
    pub const IGNORE_LOCAL_BODIES: Self = Self(16);
    /// Always present
    pub const ALWAYS_EXISTS: Self = Self(32);
    /// Unknown
    pub const UNKNOWN_6: Self = Self(64);
    /// Disable simulation
    pub const NO_SIMULATION: Self = Self(128);
    /// Unknown
    pub const UNKNOWN_9: 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 RigidBodyFlag {
    type Output = Self;
    #[inline]
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

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

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

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

/// Shader family that prefixes a data-driven material's permutation name
///
/// Selects the base token the renderer seeds the effect-name hash with, before appending the fragment names.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MaterialShaderType {
    /// "Material"
    Material = 0,
    /// "MaterialMedium"
    MaterialMedium = 1,
    /// "MaterialSimple"
    MaterialSimple = 2,
    /// "MaterialParticle"
    MaterialParticle = 3,
    /// "MaterialSplat"
    MaterialSplat = 4,
}

impl TryFrom<i32> for MaterialShaderType {
    type Error = crate::Error;
    fn try_from(v: i32) -> Result<Self, crate::Error> {
        match v {
            0 => Ok(MaterialShaderType::Material),
            1 => Ok(MaterialShaderType::MaterialMedium),
            2 => Ok(MaterialShaderType::MaterialSimple),
            3 => Ok(MaterialShaderType::MaterialParticle),
            4 => Ok(MaterialShaderType::MaterialSplat),
            other => Err(crate::Error::UnknownEnum {
                name: "MaterialShaderType",
                value: other,
            }),
        }
    }
}

/// Color stored as BGRA (4 bytes)
///
/// Blue-green-red-alpha byte order, matching the M3 on-disk format.
pub struct ColorBGRA {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ColorBGRA>,
}

impl Drop for ColorBGRA {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ColorBGRA_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_M3ColorBGRA) -> 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_m3_M3ColorBGRA_new();
            Self::from_raw(raw).expect("native ColorBGRA allocation failed")
        }
    }

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

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

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

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

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

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

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

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

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

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

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

impl ColorBGR {
    /// # 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_M3ColorBGR) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ColorBGR { 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 ColorBGR {}

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

impl ColorBGR {
    /// # 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_m3_M3ColorBGR_new();
            Self::from_raw(raw).expect("native ColorBGR allocation failed")
        }
    }

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

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

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

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

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

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

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

/// Axis-aligned bounding box with bounding sphere radius (28 bytes)
///
/// Used throughout M3 for model bounds, collision bounds, and per-region extents.
pub struct Extent {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Extent>,
}

impl Drop for Extent {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Extent_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_M3Extent) -> 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_m3_M3Extent_new();
            Self::from_raw(raw).expect("native Extent allocation failed")
        }
    }

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

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

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

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

    /// Bounding sphere radius
    pub fn radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Extent_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_m3_M3Extent_set_radius(self.raw.as_ptr(), value) }
    }
}

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

/// EVNT — Animation event (v0–v2, 104–108 bytes)
///
/// Named event triggered at a specific bone with an optional type code and parameter string. Used for sound cues, spawn effects, etc.
pub struct Event {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Event>,
}

impl Drop for Event {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Event_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_M3Event) -> 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_m3_M3Event_new();
            Self::from_raw(raw).expect("native Event allocation failed")
        }
    }

    /// Event name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe { crate::support::take_string(ffi::whiteout_m3_M3Event_get_name(self.raw.as_ptr())) }
    }

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

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

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

    /// Index into BONE array
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Event_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_m3_M3Event_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Event_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_m3_M3Event_set_padding(self.raw.as_ptr(), value) }
    }

    /// Engine-specific event type code
    pub fn event_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Event_get_eventType(self.raw.as_ptr()) }
    }

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

    /// Optional parameter string (`Ref<CHAR>`)
    pub fn option_string(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3Event_get_optionString(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// RTT channel index
    pub fn rtt_channel_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Event_get_rttChannelIndex(self.raw.as_ptr()) }
    }

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

    /// Extra parameter (v2+)
    pub fn extra_parameter(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Event_get_extraParameter(self.raw.as_ptr()) }
    }

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

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

/// SEQS — Animation sequence (v0–v2, up to 92 bytes)
///
/// Defines a named animation clip with frame range, playback speed, looping flags, blend time, and bounding volume.
pub struct Sequence {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Sequence>,
}

impl Drop for Sequence {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Sequence_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_M3Sequence) -> 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_m3_M3Sequence_new();
            Self::from_raw(raw).expect("native Sequence allocation failed")
        }
    }

    /// Unique sequence identifier
    pub fn id(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_id(self.raw.as_ptr()) }
    }

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

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

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

    /// Sequence name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3Sequence_get_name(self.raw.as_ptr()))
        }
    }

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

    /// First frame (inclusive)
    pub fn start_frame(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_startFrame(self.raw.as_ptr()) }
    }

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

    /// Last frame (inclusive)
    pub fn end_frame(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_endFrame(self.raw.as_ptr()) }
    }

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

    /// Movement speed multiplier
    pub fn move_speed(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_moveSpeed(self.raw.as_ptr()) }
    }

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

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

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

    /// Selection frequency / priority weight
    pub fn frequency(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_frequency(self.raw.as_ptr()) }
    }

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

    /// Replay region start frame
    pub fn replay_start(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_replayStart(self.raw.as_ptr()) }
    }

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

    /// Replay region end frame
    pub fn replay_end(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_replayEnd(self.raw.as_ptr()) }
    }

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

    /// Blend-in time (ms)
    pub fn blend_time(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Sequence_get_blendTime(self.raw.as_ptr()) }
    }

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

    /// Animated bounding volume
    /// Borrows the field in place — no copy, no allocation.
    pub fn bounds(&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_m3_M3Sequence_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bounds_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_m3_M3Sequence_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animation set indices (U8__)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn animation_sets(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Sequence_get_animationSets_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Sequence_get_animationSets_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 animation_sets_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Sequence_get_animationSets_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3Sequence_get_animationSets_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_animation_sets(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Sequence_assign_animationSets(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

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

/// STC_ — Sub-track container (v0–v4, 204 bytes)
///
/// Binds animation IDs to concrete keyframe data stored in 13 typed AnimBlock arrays (slots 0–12). Each slot handles a different value type: events, vectors, quaternions, colors, scalars, flags, and bounding extents.
pub struct SubTrackContainer {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3SubTrackContainer>,
}

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

impl SubTrackContainer {
    /// # 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_M3SubTrackContainer) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SubTrackContainer { 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 SubTrackContainer {}

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

impl SubTrackContainer {
    /// # 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_m3_M3SubTrackContainer_new();
            Self::from_raw(raw).expect("native SubTrackContainer allocation failed")
        }
    }

    /// Container name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3SubTrackContainer_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Non-zero if runs concurrently
    pub fn runs_concurrent(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SubTrackContainer_get_runsConcurrent(self.raw.as_ptr()) }
    }

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

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

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

    /// Parent STS_ index
    pub fn animation_state_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SubTrackContainer_get_animationStateIndex(self.raw.as_ptr()) }
    }

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

    /// Second copy of the STS_ index; every one of the 2,197 shipped containers repeats the index here
    pub fn animation_state_index_copy(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m3_M3SubTrackContainer_get_animationStateIndexCopy(self.raw.as_ptr())
        }
    }

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

    /// Animation IDs (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn anim_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3SubTrackContainer_get_animIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3SubTrackContainer_get_animIds_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_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3SubTrackContainer_get_animIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3SubTrackContainer_get_animIds_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_anim_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3SubTrackContainer_assign_animIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

    /// Animation reference indices (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn anim_refs(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3SubTrackContainer_get_animRefs_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3SubTrackContainer_get_animRefs_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_refs_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3SubTrackContainer_get_animRefs_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3SubTrackContainer_get_animRefs_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_anim_refs(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3SubTrackContainer_assign_animRefs(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

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

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

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

/// STG_ — Animation group (v0, 24 bytes)
///
/// Groups sub-track containers by name for organizational purposes.
pub struct AnimationGroup {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimationGroup>,
}

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

impl AnimationGroup {
    /// # 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_M3AnimationGroup) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationGroup { 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 AnimationGroup {}

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

impl AnimationGroup {
    /// # 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_m3_M3AnimationGroup_new();
            Self::from_raw(raw).expect("native AnimationGroup allocation failed")
        }
    }

    /// Group name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3AnimationGroup_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Indices into STC_ array (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn subtrack_indices(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3AnimationGroup_get_subtrackIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AnimationGroup_get_subtrackIndices_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 subtrack_indices_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3AnimationGroup_get_subtrackIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AnimationGroup_get_subtrackIndices_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_subtrack_indices(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3AnimationGroup_assign_subtrackIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

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

/// STS_ — Animation state (v0, 28 bytes)
///
/// Top-level animation state containing a set of animation IDs and 16 bytes of unknown state data.
pub struct AnimationState {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimationState>,
}

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

impl AnimationState {
    /// # 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_M3AnimationState) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimationState { 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 AnimationState {}

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

impl AnimationState {
    /// # 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_m3_M3AnimationState_new();
            Self::from_raw(raw).expect("native AnimationState allocation failed")
        }
    }

    /// Animation IDs (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn anim_ids(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3AnimationState_get_animIds_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AnimationState_get_animIds_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_ids_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3AnimationState_get_animIds_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3AnimationState_get_animIds_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_anim_ids(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3AnimationState_assign_animIds(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

    /// Unknown state data (16 bytes)
    /// Number of elements — a fixed-size C++ array.
    pub const fn unknown_len() -> usize {
        16
    }

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

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

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

/// BSET — Bone animation set (v0, 32 bytes)
///
/// Maps a bone to specific animation sequences with fallback support. In practice, always null in observed corpus data.
pub struct BoneAnimationSet {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3BoneAnimationSet>,
}

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

impl BoneAnimationSet {
    /// # 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_M3BoneAnimationSet) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| BoneAnimationSet { 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 BoneAnimationSet {}

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

impl BoneAnimationSet {
    /// # 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_m3_M3BoneAnimationSet_new();
            Self::from_raw(raw).expect("native BoneAnimationSet allocation failed")
        }
    }

    /// Primary sequence index
    pub fn animation_sequence_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3BoneAnimationSet_get_animationSequenceIndex(self.raw.as_ptr()) }
    }

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

    /// Fallback sequence index
    pub fn fallback_sequence_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3BoneAnimationSet_get_fallbackSequenceIndex(self.raw.as_ptr()) }
    }

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

    /// Set name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3BoneAnimationSet_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Split item indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn split_items(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3BoneAnimationSet_get_splitItems_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3BoneAnimationSet_get_splitItems_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 split_items_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3BoneAnimationSet_get_splitItems_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3BoneAnimationSet_get_splitItems_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_split_items(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3BoneAnimationSet_assign_splitItems(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

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

/// PAR_ — Particle emitter (v10–v24, 1300–1496 bytes)
///
/// The most complex M3 chunk type. Contains bone/material binding, emission shape/rate, per-particle lifetime/velocity/color/size/rotation curves, physics (drag, mass, forces), noise, collision, flipbook, variation channels, spline data, LOD, trails, and splat references. Version extensions add additional flags, force multipliers, UV transforms, phase shift, and ribbon-on-bounce parameters.
pub struct ParticleEmitter {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ParticleEmitter>,
}

impl Drop for ParticleEmitter {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_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_M3ParticleEmitter) -> 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_m3_M3ParticleEmitter_new();
            Self::from_raw(raw).expect("native ParticleEmitter allocation failed")
        }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_boneIndex(self.raw.as_ptr()) }
    }

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

    /// Index into MATM material map array
    pub fn material_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_materialIndex(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Kill radius (particles beyond this are destroyed)
    pub fn kill_radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_killRadius(self.raw.as_ptr()) }
    }

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

    /// Gravity X component (expected 0)
    pub fn gravity_x(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_gravityX(self.raw.as_ptr()) }
    }

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

    /// Gravity Y component (expected 0)
    pub fn gravity_y(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_gravityY(self.raw.as_ptr()) }
    }

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

    /// Gravity Z component
    pub fn gravity(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_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_m3_M3ParticleEmitter_set_gravity(self.raw.as_ptr(), value) }
    }

    /// Size midpoint time (0–1, v12+)
    pub fn size_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_sizeMidTime(self.raw.as_ptr()) }
    }

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

    /// Color midpoint time (0–1, v12+)
    pub fn color_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_colorMidTime(self.raw.as_ptr()) }
    }

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

    /// Alpha midpoint time (0–1, v12+)
    pub fn alpha_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_alphaMidTime(self.raw.as_ptr()) }
    }

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

    /// Rotation midpoint time (0–1, v12+)
    pub fn rotation_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_rotationMidTime(self.raw.as_ptr()) }
    }

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

    /// Size hold time at midpoint (v14+)
    pub fn size_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_sizeMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Color hold time at midpoint (v14+)
    pub fn color_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_colorMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Alpha hold time at midpoint (v14+)
    pub fn alpha_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_alphaMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Rotation hold time at midpoint (v14+)
    pub fn rotation_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_rotationMidHoldTime(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

    /// Air drag coefficient
    pub fn drag(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_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_m3_M3ParticleEmitter_set_drag(self.raw.as_ptr(), value) }
    }

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

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

    /// Random mass variation multiplier
    pub fn mass_random(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_massRandom(self.raw.as_ptr()) }
    }

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

    /// Mass–size coupling (v12+)
    pub fn mass_size_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_massSizeMultiplier(self.raw.as_ptr()) }
    }

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

    /// Local force channel bitmask
    pub fn local_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_localForces(self.raw.as_ptr()) }
    }

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

    /// World force channel bitmask
    pub fn world_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_worldForces(self.raw.as_ptr()) }
    }

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

    /// Fallback local force channels
    pub fn local_forces_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_localForcesFallback(self.raw.as_ptr()) }
    }

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

    /// Fallback world force channels
    pub fn world_forces_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_worldForcesFallback(self.raw.as_ptr()) }
    }

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

    /// World force mass multiplier (v24+)
    pub fn world_forces_mass_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m3_M3ParticleEmitter_get_worldForcesMassMultiplier(self.raw.as_ptr())
        }
    }

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

    /// Noise displacement amplitude
    pub fn noise_amplitude(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_noiseAmplitude(self.raw.as_ptr()) }
    }

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

    /// Noise spatial frequency
    pub fn noise_frequency(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_noiseFrequency(self.raw.as_ptr()) }
    }

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

    /// Noise temporal coherence
    pub fn noise_coherence(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_noiseCoherence(self.raw.as_ptr()) }
    }

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

    /// Noise edge sharpness
    pub fn noise_edge(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_noiseEdge(self.raw.as_ptr()) }
    }

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

    /// Index + length (v11+)
    pub fn index_plus_length(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_indexPlusLength(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Shape region indices (U32_, v14+), which mesh region from div to use
    /// Zero-copy view of the underlying `std::vector`.
    pub fn shape_regions(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ParticleEmitter_get_shapeRegions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ParticleEmitter_get_shapeRegions_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 shape_regions_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ParticleEmitter_get_shapeRegions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ParticleEmitter_get_shapeRegions_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_shape_regions(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ParticleEmitter_assign_shapeRegions(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

    /// Velocity randomization type
    pub fn velocity_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_velocityType(self.raw.as_ptr()) }
    }

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

    /// Enable size randomization
    pub fn size_random_enable(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_sizeRandomEnable(self.raw.as_ptr()) }
    }

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

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

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

    /// Enable rotation randomization
    pub fn rotation_random_enable(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_rotationRandomEnable(self.raw.as_ptr()) }
    }

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

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

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

    /// Enable color randomization
    pub fn color_random_enable(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_colorRandomEnable(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

    /// Enable alpha randomization
    pub fn alpha_random_enable(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_alphaRandomEnable(self.raw.as_ptr()) }
    }

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

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

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

    /// Flipbook start initial frame index
    pub fn flipbook_start_init_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookStartInitIndex(self.raw.as_ptr()) }
    }

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

    /// Flipbook start stop frame index
    pub fn flipbook_start_stop_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookStartStopIndex(self.raw.as_ptr()) }
    }

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

    /// Flipbook end initial frame index
    pub fn flipbook_end_init_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookEndInitIndex(self.raw.as_ptr()) }
    }

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

    /// Flipbook end stop frame index
    pub fn flipbook_end_stop_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookEndStopIndex(self.raw.as_ptr()) }
    }

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

    /// Flipbook midpoint time (0–1)
    pub fn flipbook_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookMidTime(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Column fraction (v12+)
    pub fn flipbook_column_fraction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookColumnFraction(self.raw.as_ptr()) }
    }

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

    /// Row fraction (v12+)
    pub fn flipbook_row_fraction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_flipbookRowFraction(self.raw.as_ptr()) }
    }

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

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

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

    /// Friction coefficient
    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_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_m3_M3ParticleEmitter_set_friction(self.raw.as_ptr(), value) }
    }

    /// Emitter index to spawn on collision (-1 = none)
    pub fn collision_spawn_index(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionSpawnIndex(self.raw.as_ptr()) }
    }

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

    /// Minimum spawn count on collision
    pub fn collision_spawn_min(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionSpawnMin(self.raw.as_ptr()) }
    }

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

    /// Maximum spawn count on collision
    pub fn collision_spawn_max(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionSpawnMax(self.raw.as_ptr()) }
    }

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

    /// Spawn probability on collision
    pub fn collision_spawn_chance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionSpawnChance(self.raw.as_ptr()) }
    }

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

    /// Spawn energy transfer
    pub fn collision_spawn_energy(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionSpawnEnergy(self.raw.as_ptr()) }
    }

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

    /// Die after N bounces
    pub fn collision_die_bounce(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_collisionDieBounce(self.raw.as_ptr()) }
    }

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

    /// Visual type → shader b_iInstanceType
    pub fn instance_type(&self) -> ParticleInstanceType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_instanceType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Tail length for Tail/Trail types
    pub fn tail_length(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_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_m3_M3ParticleEmitter_set_tailLength(self.raw.as_ptr(), value) }
    }

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

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

    /// Instance distance (v17+)
    pub fn instance_distance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_instanceDistance(self.raw.as_ptr()) }
    }

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

    /// Pitch variation type
    pub fn pitch_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_pitchType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Yaw variation type
    pub fn yaw_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_yawType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Speed variation type
    pub fn speed_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_speedType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Size variation type
    pub fn size_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_sizeType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Alpha variation type
    pub fn alpha_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_alphaType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Color variation type
    pub fn color_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_colorType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Rotation variation type
    pub fn rotation_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_rotationType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Horizontal variation type
    pub fn horizontal_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_horizontalType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Vertical variation type
    pub fn vertical_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_verticalType(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

    /// Rotation flags (v18+)
    pub fn rotation_flags(&self) -> ParticleRotationFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        ParticleRotationFlag(unsafe {
            ffi::whiteout_m3_M3ParticleEmitter_get_rotationFlags(self.raw.as_ptr())
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Spline control points (SVC3)
    pub fn spline_line_data_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_splineLineData_count(self.raw.as_ptr()) }
    }

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

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

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

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

    /// Wind influence multiplier
    pub fn wind_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_windMultiplier(self.raw.as_ptr()) }
    }

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

    /// LOD reduction level
    pub fn lod_reduce(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_lodReduce(self.raw.as_ptr()) }
    }

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

    /// LOD cut-off level
    pub fn lod_cut(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_lodCut(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

    /// Trail spawn probability
    pub fn trail_chance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_trailChance(self.raw.as_ptr()) }
    }

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

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

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

    /// Linked projector index (-1 = none)
    pub fn splat_projection_index(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_splatProjectionIndex(self.raw.as_ptr()) }
    }

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

    /// Splat spawn probability
    pub fn splat_chance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_splatChance(self.raw.as_ptr()) }
    }

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

    /// Emitter copy indices (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn copy_indices(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ParticleEmitter_get_copyIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ParticleEmitter_get_copyIndices_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 copy_indices_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ParticleEmitter_get_copyIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ParticleEmitter_get_copyIndices_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_copy_indices(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ParticleEmitter_assign_copyIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

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

    /// Ribbon spawn probability on bounce (v23+)
    pub fn spawn_ribbon_on_bounce_chance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m3_M3ParticleEmitter_get_spawnRibbonOnBounceChance(self.raw.as_ptr())
        }
    }

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

    /// Index into RIB_ array (-1 = none, v23+)
    pub fn ribbon_link_index(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitter_get_ribbonLinkIndex(self.raw.as_ptr()) }
    }

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

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

/// PARC — Particle emitter copy (v0, 40 bytes)
///
/// Lightweight copy of a particle emitter with overridden emission rate, squirt amount, and bone index. References the original PAR_ via Model.copyIndices.
pub struct ParticleEmitterCopy {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ParticleEmitterCopy>,
}

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

impl ParticleEmitterCopy {
    /// # 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_M3ParticleEmitterCopy) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ParticleEmitterCopy { 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 ParticleEmitterCopy {}

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

impl ParticleEmitterCopy {
    /// # 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_m3_M3ParticleEmitterCopy_new();
            Self::from_raw(raw).expect("native ParticleEmitterCopy allocation failed")
        }
    }

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

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

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

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

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ParticleEmitterCopy_get_boneIndex(self.raw.as_ptr()) }
    }

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

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

/// SRIB — Spline ribbon segment (v0, 272 bytes)
///
/// Defines a single segment of a spline-based ribbon with emission offset/vector, velocity, bone binding, and pitch/yaw/velocity variation channels.
pub struct SplineRibbon {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3SplineRibbon>,
}

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

impl SplineRibbon {
    /// # 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_M3SplineRibbon) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SplineRibbon { 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 SplineRibbon {}

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

impl SplineRibbon {
    /// # 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_m3_M3SplineRibbon_new();
            Self::from_raw(raw).expect("native SplineRibbon allocation failed")
        }
    }

    /// Emission point offset from bone
    pub fn emission_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_m3_M3SplineRibbon_get_emissionOffset(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

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

    /// Emission direction vector
    pub fn emission_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_m3_M3SplineRibbon_get_emissionVector(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

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

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

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

    /// Reserved (always 0)
    pub fn reserved(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_reserved(self.raw.as_ptr()) }
    }

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

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_boneIndex(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Yaw variation type
    pub fn yaw_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_yawType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Pitch variation type
    pub fn pitch_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_pitchType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Velocity variation type
    pub fn velocity_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_velocityType(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

    /// Precomputed ≈ 0.01 / |emissionVector|
    pub fn emission_vector_norm_factor(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_emissionVectorNormFactor(self.raw.as_ptr()) }
    }

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

    /// Precomputed ≈ 0.01 / velocity.initValue
    pub fn velocity_norm_factor(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SplineRibbon_get_velocityNormFactor(self.raw.as_ptr()) }
    }

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

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

/// RIB_ — Ribbon emitter (v4–v9, 744–760 bytes)
///
/// Ribbon strip effect with per-particle lifetime, velocity, color/size curves, physics, noise, spline segments, variation channels, and smoothing/collision settings. Shares many fields with ParticleEmitter.
pub struct RibbonEmitter {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3RibbonEmitter>,
}

impl Drop for RibbonEmitter {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_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_M3RibbonEmitter) -> 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_m3_M3RibbonEmitter_new();
            Self::from_raw(raw).expect("native RibbonEmitter allocation failed")
        }
    }

    /// Primary bone index
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_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_m3_M3RibbonEmitter_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Fallback bone index
    pub fn bone_index_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_boneIndexFallback(self.raw.as_ptr()) }
    }

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

    /// Index into MATM material map array
    pub fn material_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_materialIndex(self.raw.as_ptr()) }
    }

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

    /// Additional flags (v8+)
    pub fn additional_flags(&self) -> RibbonAdditionalFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        RibbonAdditionalFlag(unsafe {
            ffi::whiteout_m3_M3RibbonEmitter_get_additionalFlags(self.raw.as_ptr())
        })
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Gravity X component
    pub fn gravity_x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_gravityX(self.raw.as_ptr()) }
    }

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

    /// Gravity Y component
    pub fn gravity_y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_gravityY(self.raw.as_ptr()) }
    }

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

    /// Gravity Z component
    pub fn gravity(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_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_m3_M3RibbonEmitter_set_gravity(self.raw.as_ptr(), value) }
    }

    /// Size midpoint time (0–1)
    pub fn size_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_sizeMidTime(self.raw.as_ptr()) }
    }

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

    /// Color midpoint time (0–1)
    pub fn color_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_colorMidTime(self.raw.as_ptr()) }
    }

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

    /// Alpha midpoint time (0–1)
    pub fn alpha_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_alphaMidTime(self.raw.as_ptr()) }
    }

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

    /// Rotation midpoint time (0–1)
    pub fn rotation_mid_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_rotationMidTime(self.raw.as_ptr()) }
    }

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

    /// Size hold time at midpoint
    pub fn size_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_sizeMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Color hold time at midpoint
    pub fn color_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_colorMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Alpha hold time at midpoint
    pub fn alpha_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_alphaMidHoldTime(self.raw.as_ptr()) }
    }

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

    /// Rotation hold time at midpoint
    pub fn rotation_mid_hold_time(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_rotationMidHoldTime(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

    /// Air drag coefficient
    pub fn drag(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_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_m3_M3RibbonEmitter_set_drag(self.raw.as_ptr(), value) }
    }

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

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

    /// Random mass variation
    pub fn mass_random(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_massRandom(self.raw.as_ptr()) }
    }

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

    /// Mass–size coupling
    pub fn mass_size_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_massSizeMultiplier(self.raw.as_ptr()) }
    }

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

    /// Local force channel bitmask
    pub fn local_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_localForces(self.raw.as_ptr()) }
    }

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

    /// World force channel bitmask
    pub fn world_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_worldForces(self.raw.as_ptr()) }
    }

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

    /// Fallback local force channels
    pub fn local_forces_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_localForcesFallback(self.raw.as_ptr()) }
    }

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

    /// Fallback world force channels
    pub fn world_forces_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_worldForcesFallback(self.raw.as_ptr()) }
    }

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

    /// World force mass multiplier
    pub fn world_forces_mass_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_worldForcesMassMultiplier(self.raw.as_ptr()) }
    }

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

    /// Noise displacement amplitude
    pub fn noise_amplitude(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_noiseAmplitude(self.raw.as_ptr()) }
    }

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

    /// Noise spatial frequency
    pub fn noise_frequency(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_noiseFrequency(self.raw.as_ptr()) }
    }

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

    /// Noise temporal coherence
    pub fn noise_coherence(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_noiseCoherence(self.raw.as_ptr()) }
    }

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

    /// Noise edge sharpness
    pub fn noise_edge(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_noiseEdge(self.raw.as_ptr()) }
    }

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

    /// Index + length
    pub fn index_plus_length(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_indexPlusLength(self.raw.as_ptr()) }
    }

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

    /// Emitter shape type
    pub fn emitter_shape(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_emitterShape(self.raw.as_ptr()) }
    }

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

    /// Ribbon cross-section type
    pub fn ribbon_type(&self) -> RibbonType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_ribbonType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Number of ribbon divisions
    pub fn divisions(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_divisions(self.raw.as_ptr()) }
    }

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

    /// Number of cross-section edges
    pub fn edges(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_edges(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Spline ribbon segments (SRIB)
    pub fn spline_ribbons_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_splineRibbons_count(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

    /// Size interpolation mode
    pub fn size_smoothing(&self) -> InterpolationMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_sizeSmoothing(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Color interpolation mode
    pub fn color_smoothing(&self) -> InterpolationMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_colorSmoothing(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Friction coefficient
    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_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_m3_M3RibbonEmitter_set_friction(self.raw.as_ptr(), value) }
    }

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

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

    /// LOD reduction level
    pub fn lod_reduce(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_lodReduce(self.raw.as_ptr()) }
    }

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

    /// LOD cut-off level
    pub fn lod_cut(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_lodCut(self.raw.as_ptr()) }
    }

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

    /// Yaw variation type
    pub fn yaw_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_yawType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Pitch variation type
    pub fn pitch_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_pitchType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Speed variation type
    pub fn speed_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_speedType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Size variation type
    pub fn size_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_sizeType(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Alpha variation type
    pub fn alpha_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RibbonEmitter_get_alphaType(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

/// PROJ — Projector / decal (v0–v5, 388 bytes)
///
/// Projects a material onto scene geometry with animated offset, orientation, field of view, aspect ratio, clipping planes, alpha lifecycle, and attenuation distance.
pub struct Projector {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Projector>,
}

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

impl Projector {
    /// # 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_M3Projector) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Projector { 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 Projector {}

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

impl Projector {
    /// # 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_m3_M3Projector_new();
            Self::from_raw(raw).expect("native Projector allocation failed")
        }
    }

    /// Projection type (ortho/perspective)
    pub fn projection_type(&self) -> ProjectionType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3Projector_get_projectionType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Index into BONE array
    pub fn bone(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_bone(self.raw.as_ptr()) }
    }

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

    /// Index into MATM material map
    pub fn material_reference_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_materialReferenceIndex(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Alpha at creation
    pub fn alpha_init(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_alphaInit(self.raw.as_ptr()) }
    }

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

    /// Alpha at midpoint
    pub fn alpha_mid(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_alphaMid(self.raw.as_ptr()) }
    }

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

    /// Alpha at end
    pub fn alpha_end(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_alphaEnd(self.raw.as_ptr()) }
    }

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

    /// Attack phase duration
    pub fn lifetime_attack(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeAttack(self.raw.as_ptr()) }
    }

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

    /// Attack target time
    pub fn lifetime_attack_to(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeAttackTo(self.raw.as_ptr()) }
    }

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

    /// Hold phase duration
    pub fn lifetime_hold(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeHold(self.raw.as_ptr()) }
    }

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

    /// Hold target time
    pub fn lifetime_hold_to(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeHoldTo(self.raw.as_ptr()) }
    }

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

    /// Decay phase duration
    pub fn lifetime_decay(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeDecay(self.raw.as_ptr()) }
    }

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

    /// Decay target time
    pub fn lifetime_decay_to(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lifetimeDecayTo(self.raw.as_ptr()) }
    }

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

    /// Distance-based attenuation
    pub fn attenuation_distance(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_attenuationDistance(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// LOD reduction level
    pub fn lod_reduce(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lodReduce(self.raw.as_ptr()) }
    }

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

    /// LOD cut-off level
    pub fn lod_cut(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Projector_get_lodCut(self.raw.as_ptr()) }
    }

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

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

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

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

/// MATM — Material map entry (v0, 8 bytes)
///
/// Maps a material type enum to an index into the corresponding material array. The MODL root references an array of these; the renderer uses materialType to dispatch to the correct material vector.
pub struct MaterialMap {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3MaterialMap>,
}

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

impl MaterialMap {
    /// # 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_M3MaterialMap) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| MaterialMap { 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 MaterialMap {}

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

impl MaterialMap {
    /// # 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_m3_M3MaterialMap_new();
            Self::from_raw(raw).expect("native MaterialMap allocation failed")
        }
    }

    /// Material type (1=standard, 2=displacement, etc.)
    pub fn material_type(&self) -> MaterialType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3MaterialMap_get_materialType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Index into the typed material array
    pub fn material_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MaterialMap_get_materialIndex(self.raw.as_ptr()) }
    }

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

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

/// LAYR — Texture layer (v0–v26, 352–464 bytes)
///
/// A single texture binding with animated color tint, UV transforms, flipbook parameters, fresnel settings, and AVI video playback controls. Materials embed multiple optional TextureLayer instances for diffuse, specular, emissive, normal, and other texture slots.
///
/// Every field is initialised for the same reason `StandardMaterial`'s are: the parser fills all of them, but a conversion builds a layer from scratch (`layerFrom`) and a default-initialised one handed to the writer carries stack junk into the file. It did -- the halves of live heap pointers landed in `flipbookColumns`, `textureSource` and the fresnel fields of every exported layer, and the Galaxy editor crashed on the ones whose low byte came out zero (`reference_m3_layer_stack_junk`).
pub struct TextureLayer {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3TextureLayer>,
}

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

impl TextureLayer {
    /// # 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_M3TextureLayer) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TextureLayer { 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 TextureLayer {}

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

impl TextureLayer {
    /// # 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_m3_M3TextureLayer_new();
            Self::from_raw(raw).expect("native TextureLayer allocation failed")
        }
    }

    /// Layer identifier
    pub fn id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_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_m3_M3TextureLayer_set_id(self.raw.as_ptr(), value) }
    }

    /// Texture file path (`Ref<CHAR>`)
    pub fn texture_path(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3TextureLayer_get_texturePath(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

    /// Layer flags (wrap, flipbook, video, etc.)
    pub fn flags(&self) -> TextureLayerFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        TextureLayerFlag(unsafe { ffi::whiteout_m3_M3TextureLayer_get_flags(self.raw.as_ptr()) })
    }

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

    /// UV mapping source
    pub fn uv_mapping(&self) -> UVMappingMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_uvMapping(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

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

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

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

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

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

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

    /// POC texture reference
    pub fn poc_texture(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_pocTexture(self.raw.as_ptr()) }
    }

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

    /// Noise amplitude (v24+)
    pub fn noise_amplitude(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_noiseAmplitude(self.raw.as_ptr()) }
    }

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

    /// Noise frequency (v24+)
    pub fn noise_frequency(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_noiseFrequency(self.raw.as_ptr()) }
    }

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

    /// Texture source override
    pub fn texture_source(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_textureSource(self.raw.as_ptr()) }
    }

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

    /// AVI playback frame rate
    pub fn avi_frame_rate(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_aviFrameRate(self.raw.as_ptr()) }
    }

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

    /// AVI start frame
    pub fn avi_start(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_aviStart(self.raw.as_ptr()) }
    }

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

    /// AVI stop frame
    pub fn avi_stop(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_aviStop(self.raw.as_ptr()) }
    }

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

    /// AVI loop mode
    pub fn avi_loop(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_aviLoop(self.raw.as_ptr()) }
    }

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

    /// AVI sync mode
    pub fn avi_sync(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_aviSync(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Flipbook grid rows
    pub fn flipbook_rows(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_flipbookRows(self.raw.as_ptr()) }
    }

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

    /// Flipbook grid columns
    pub fn flipbook_columns(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_flipbookColumns(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Layer whose UV setup this one shares; -1 = own
    pub fn uv_source_related(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_uvSourceRelated(self.raw.as_ptr()) }
    }

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

    /// Fresnel effect mode
    pub fn fresnel_mode(&self) -> FresnelMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_fresnelMode(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Fresnel exponent (edge sharpness)
    pub fn fresnel_exponent(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_fresnelExponent(self.raw.as_ptr()) }
    }

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

    /// Fresnel minimum intensity
    pub fn fresnel_min(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_fresnelMin(self.raw.as_ptr()) }
    }

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

    /// Fresnel maximum intensity
    pub fn fresnel_max(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_fresnelMax(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

    /// UV density hint (v0–v25, absent in v26)
    pub fn uv_density(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TextureLayer_get_uvDensity(self.raw.as_ptr()) }
    }

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

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

/// MAT_ — Standard material (v0–v20, 268–352 bytes)
///
/// The primary material type with up to 18 texture layers (diffuse, specular, emissive, normal, height, etc.), blend mode, HDR multipliers, and per-version extensions for normal-blend and gloss layers.
pub struct StandardMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3StandardMaterial>,
}

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

impl StandardMaterial {
    /// # 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_M3StandardMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| StandardMaterial { 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 StandardMaterial {}

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

impl StandardMaterial {
    /// # 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_m3_M3StandardMaterial_new();
            Self::from_raw(raw).expect("native StandardMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3StandardMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

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

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

    /// Alpha blend mode
    pub fn blend_mode(&self) -> BlendMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_blendMode(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Render priority (lower = earlier)
    pub fn priority(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_priority(self.raw.as_ptr()) }
    }

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

    /// RTT channel mask
    pub fn rtt_channels(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_rttChannels(self.raw.as_ptr()) }
    }

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

    /// Specular highlight exponent
    pub fn specular_exponent(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_specularExponent(self.raw.as_ptr()) }
    }

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

    /// Depth blend falloff distance
    pub fn depth_blend_falloff(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_depthBlendFalloff(self.raw.as_ptr()) }
    }

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

    /// Alpha test cut-off value
    pub fn alpha_test_threshold(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_alphaTestThreshold(self.raw.as_ptr()) }
    }

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

    /// HDR specular multiplier
    pub fn hdr_specular_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_hdrSpecularMultiplier(self.raw.as_ptr()) }
    }

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

    /// HDR emissive multiplier
    pub fn hdr_emissive_multiplier(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_hdrEmissiveMultiplier(self.raw.as_ptr()) }
    }

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

    /// HDR environment constant (v20)
    pub fn hdr_environment_constant(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_hdrEnvironmentConstant(self.raw.as_ptr()) }
    }

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

    /// HDR environment diffuse (v20)
    pub fn hdr_environment_diffuse(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_hdrEnvironmentDiffuse(self.raw.as_ptr()) }
    }

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

    /// HDR environment specular (v20)
    pub fn hdr_environment_specular(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_hdrEnvironmentSpecular(self.raw.as_ptr()) }
    }

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

    /// Material class (unit, building, etc.)
    pub fn material_class(&self) -> MaterialClass {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_materialClass(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Layer blend operation
    pub fn layer_blend_mode(&self) -> LayerBlendOp {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_layerBlendMode(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Emissive layer 1 blend mode
    pub fn emissive_blend_mode_1(&self) -> LayerBlendOp {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_emissiveBlendMode1(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Emissive layer 2 blend mode
    pub fn emissive_blend_mode_2(&self) -> LayerBlendOp {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_emissiveBlendMode2(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Specular computation mode
    pub fn specular_mode(&self) -> SpecularMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3StandardMaterial_get_specularMode(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

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

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

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

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

    /// Normal blend factors (v19+)
    pub fn normal_blend_factors_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe {
            ffi::whiteout_m3_M3StandardMaterial_get_normalBlendFactors_count(self.raw.as_ptr())
        }
    }

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

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

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

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

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

/// DIS_ — Displacement material (v0–v4, 68 bytes)
///
/// Applies vertex displacement via a normal map and animated strength.
pub struct DisplacementMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3DisplacementMaterial>,
}

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

impl DisplacementMaterial {
    /// # 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_M3DisplacementMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DisplacementMaterial { 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 DisplacementMaterial {}

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

impl DisplacementMaterial {
    /// # 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_m3_M3DisplacementMaterial_new();
            Self::from_raw(raw).expect("native DisplacementMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3DisplacementMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

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

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

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

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

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

/// CMS_ — Composite material section (v0, 24 bytes)
///
/// A single section within a composite material, referencing another material index with an animated blend multiplier.
pub struct CompositeSection {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3CompositeSection>,
}

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

impl CompositeSection {
    /// # 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_M3CompositeSection) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CompositeSection { 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 CompositeSection {}

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

impl CompositeSection {
    /// # 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_m3_M3CompositeSection_new();
            Self::from_raw(raw).expect("native CompositeSection allocation failed")
        }
    }

    /// Index into MATM array
    pub fn material_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3CompositeSection_get_materialIndex(self.raw.as_ptr()) }
    }

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

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

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

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

/// CMP_ — Composite material (v0–v2, 28 bytes)
///
/// Blends multiple sub-materials via CompositeSection entries.
pub struct CompositeMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3CompositeMaterial>,
}

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

impl CompositeMaterial {
    /// # 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_M3CompositeMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CompositeMaterial { 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 CompositeMaterial {}

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

impl CompositeMaterial {
    /// # 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_m3_M3CompositeMaterial_new();
            Self::from_raw(raw).expect("native CompositeMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3CompositeMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

    /// Sub-material sections (CMS_)
    pub fn sections_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3CompositeMaterial_get_sections_count(self.raw.as_ptr()) }
    }

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

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

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

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

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

/// TER_ — Terrain material (v0–v1, 28 bytes)
///
/// Simple terrain-specific material with a single texture layer.
pub struct TerrainMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3TerrainMaterial>,
}

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

impl TerrainMaterial {
    /// # 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_M3TerrainMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TerrainMaterial { 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 TerrainMaterial {}

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

impl TerrainMaterial {
    /// # 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_m3_M3TerrainMaterial_new();
            Self::from_raw(raw).expect("native TerrainMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3TerrainMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

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

/// VOL_ — Volume material (v0, 84 bytes)
///
/// Volumetric rendering material with density falloff, color map, and two noise maps for procedural volumetric effects.
pub struct VolumeMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3VolumeMaterial>,
}

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

impl VolumeMaterial {
    /// # 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_M3VolumeMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| VolumeMaterial { 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 VolumeMaterial {}

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

impl VolumeMaterial {
    /// # 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_m3_M3VolumeMaterial_new();
            Self::from_raw(raw).expect("native VolumeMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3VolumeMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

    /// Density falloff type
    pub fn falloff_type(&self) -> VolumeFalloffType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3VolumeMaterial_get_falloffType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

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

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

    /// Alpha test threshold
    pub fn alpha_threshold(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3VolumeMaterial_get_alphaThreshold(self.raw.as_ptr()) }
    }

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

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

/// HAI_ — Hair material (defunct, v0, 116 bytes)
///
/// Anisotropic hair rendering material with specular shift and AO. Always null in observed corpus data.
pub struct HairMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3HairMaterial>,
}

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

impl HairMaterial {
    /// # 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_M3HairMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| HairMaterial { 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 HairMaterial {}

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

impl HairMaterial {
    /// # 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_m3_M3HairMaterial_new();
            Self::from_raw(raw).expect("native HairMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3HairMaterial_get_name(self.raw.as_ptr()))
        }
    }

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

    /// Primary specular shift
    pub fn shift_primary(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HairMaterial_get_shiftPrimary(self.raw.as_ptr()) }
    }

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

    /// Secondary specular shift
    pub fn shift_secondary(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HairMaterial_get_shiftSecondary(self.raw.as_ptr()) }
    }

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

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

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

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

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

    /// Primary specular exponent
    pub fn spec_exponent_0(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HairMaterial_get_specExponent0(self.raw.as_ptr()) }
    }

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

    /// Secondary specular exponent
    pub fn spec_exponent_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HairMaterial_get_specExponent1(self.raw.as_ptr()) }
    }

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

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

/// VON_ — Volume noise material (v0, 268 bytes)
///
/// Volumetric noise-based rendering material with animated density, falloff, scroll rate, position, scale, and rotation. Used for gas/smoke/cloud effects.
pub struct VolumeNoiseMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3VolumeNoiseMaterial>,
}

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

impl VolumeNoiseMaterial {
    /// # 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_M3VolumeNoiseMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| VolumeNoiseMaterial { 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 VolumeNoiseMaterial {}

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

impl VolumeNoiseMaterial {
    /// # 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_m3_M3VolumeNoiseMaterial_new();
            Self::from_raw(raw).expect("native VolumeNoiseMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3VolumeNoiseMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Density falloff type
    pub fn falloff_type(&self) -> VolumeFalloffType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3VolumeNoiseMaterial_get_falloffType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

    /// Camera position mode (inside/outside)
    pub fn draw_transparency(&self) -> VolumeNoiseCameraMode {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3VolumeNoiseMaterial_get_drawTransparency(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Alpha test threshold
    pub fn alpha_threshold(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3VolumeNoiseMaterial_get_alphaThreshold(self.raw.as_ptr()) }
    }

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

    /// Volume noise material flags
    pub fn flags(&self) -> VolumeNoiseMaterialFlag {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3VolumeNoiseMaterial_get_flags(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

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

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

/// CREP — Creep material (v0–v1, 28 bytes)
///
/// Material for Zerg creep rendering with a mask map and creep-low parameter.
pub struct CreepMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3CreepMaterial>,
}

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

impl CreepMaterial {
    /// # 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_M3CreepMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| CreepMaterial { 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 CreepMaterial {}

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

impl CreepMaterial {
    /// # 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_m3_M3CreepMaterial_new();
            Self::from_raw(raw).expect("native CreepMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3CreepMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Creep low parameter
    pub fn creep_low(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3CreepMaterial_get_creepLow(self.raw.as_ptr()) }
    }

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

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

/// STBM — Splat terrain bake material (v0, 48 bytes)
///
/// Material for baked terrain splat rendering with diffuse, normal, and specular texture layers.
pub struct STBMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3STBMaterial>,
}

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

impl STBMaterial {
    /// # 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_M3STBMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| STBMaterial { 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 STBMaterial {}

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

impl STBMaterial {
    /// # 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_m3_M3STBMaterial_new();
            Self::from_raw(raw).expect("native STBMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3STBMaterial_get_name(self.raw.as_ptr()))
        }
    }

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

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

/// REF_ — Reflection material (v0–v3, 84–160 bytes)
///
/// Planar or cube-map reflection material with animated reflection/displacement strength, blur, and multiple texture layers.
pub struct ReflectionMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ReflectionMaterial>,
}

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

impl ReflectionMaterial {
    /// # 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_M3ReflectionMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ReflectionMaterial { 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 ReflectionMaterial {}

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

impl ReflectionMaterial {
    /// # 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_m3_M3ReflectionMaterial_new();
            Self::from_raw(raw).expect("native ReflectionMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3ReflectionMaterial_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Index of the DataDrivenMaterial this was converted into, 0xFFFFFFFF if none (v3+). Written by the Heroes load-time conversion pass, not a material parameter; meaningless in a model that carries no MADD chunk. v3 exists only to hold it. Defaulted because an invented REF_ has no link to name, and a v3 record that says anything else points the Heroes loader at a MADD index.
    pub fn unknown_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ReflectionMaterial_get_unknown2(self.raw.as_ptr()) }
    }

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

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

/// LFSB — Sub-flare element (v0–v2, 56 bytes)
///
/// A single flare element within a LensFlare material, with position, size, scale, fade, color, and offset parameters.
pub struct SubFlare {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3SubFlare>,
}

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

impl SubFlare {
    /// # 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_M3SubFlare) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| SubFlare { 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 SubFlare {}

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

impl SubFlare {
    /// # 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_m3_M3SubFlare_new();
            Self::from_raw(raw).expect("native SubFlare allocation failed")
        }
    }

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

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

    /// Position along the flare axis (0–1)
    pub fn position(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SubFlare_get_position(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

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

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

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

    /// Whether to face the flare center
    pub fn face_center(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3SubFlare_get_faceCenter(self.raw.as_ptr()) }
    }

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

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

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

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

/// LFLR — Lens flare material (v0–v3, 152 bytes)
///
/// Lens flare effect with animated intensity, color, HDR, size, sub-flare elements, and flipbook texture grid parameters.
pub struct LensFlare {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3LensFlare>,
}

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

impl LensFlare {
    /// # 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_M3LensFlare) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| LensFlare { 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 LensFlare {}

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

impl LensFlare {
    /// # 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_m3_M3LensFlare_new();
            Self::from_raw(raw).expect("native LensFlare allocation failed")
        }
    }

    /// Flare name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3LensFlare_get_name(self.raw.as_ptr()))
        }
    }

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

    /// Sub-flare elements (LFSB)
    pub fn sub_flares_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3LensFlare_get_subFlares_count(self.raw.as_ptr()) }
    }

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

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

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

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

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

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

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

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

    /// Distance fade start
    pub fn distance_fade(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3LensFlare_get_distanceFade(self.raw.as_ptr()) }
    }

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

    /// Library name (`Ref<CHAR>`)
    pub fn lib_name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3LensFlare_get_libName(self.raw.as_ptr()))
        }
    }

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

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

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

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

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

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

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

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

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

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

/// One decoded property of a data-driven material
///
/// `data` is the raw value; its shape depends on `size`: 4 = scalar (f32, u32 enum, or BGRA colour — depends on the property), 8 = `{u32 index into DataDrivenMaterial::texturePaths, u32 texture source}`, 12 = 3 floats, 16 = 4 floats, 20 = `{u32 ColorChannelSelect, f32 multiply, f32 add, f32, u16 flags}`, 32 = `{f32 offsetU/V, tilingU/V, angleU/V/W, u32 flags}`, 48 = fresnel `{u32 FresnelMode, f32 exponent, min, max, rotation, mask}`.
pub struct DataDrivenProperty {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3DataDrivenProperty>,
}

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

impl DataDrivenProperty {
    /// # 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_M3DataDrivenProperty) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DataDrivenProperty { 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 DataDrivenProperty {}

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

impl DataDrivenProperty {
    /// # 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_m3_M3DataDrivenProperty_new();
            Self::from_raw(raw).expect("native DataDrivenProperty allocation failed")
        }
    }

    /// crc32 of the property name
    pub fn name_hash(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenProperty_get_nameHash(self.raw.as_ptr()) }
    }

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

    /// Resolved name, empty when the hash is unknown
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3DataDrivenProperty_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Raw value bytes
    /// 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_m3_M3DataDrivenProperty_get_data_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenProperty_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_m3_M3DataDrivenProperty_get_data_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3DataDrivenProperty_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_m3_M3DataDrivenProperty_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_m3_M3DataDrivenProperty_resize_data(self.raw.as_ptr(), count) }
    }
}

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

/// One shader fragment of a data-driven material, with its properties
pub struct DataDrivenGroup {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3DataDrivenGroup>,
}

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

impl DataDrivenGroup {
    /// # 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_M3DataDrivenGroup) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DataDrivenGroup { 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 DataDrivenGroup {}

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

impl DataDrivenGroup {
    /// # 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_m3_M3DataDrivenGroup_new();
            Self::from_raw(raw).expect("native DataDrivenGroup allocation failed")
        }
    }

    /// crc32 of the fragment name
    pub fn name_hash(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenGroup_get_nameHash(self.raw.as_ptr()) }
    }

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

    /// Resolved name, empty when unknown
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3DataDrivenGroup_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

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

    /// Properties, in stored order
    pub fn properties_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenGroup_get_properties_count(self.raw.as_ptr()) }
    }

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

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

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

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

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

/// The decoded contents of DataDrivenMaterial::propertyBlob
pub struct DataDrivenProperties {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3DataDrivenProperties>,
}

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

impl DataDrivenProperties {
    /// # 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_M3DataDrivenProperties) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DataDrivenProperties { 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 DataDrivenProperties {}

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

impl DataDrivenProperties {
    /// # 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_m3_M3DataDrivenProperties_new();
            Self::from_raw(raw).expect("native DataDrivenProperties allocation failed")
        }
    }

    /// Fragment groups, in stored order
    pub fn groups_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenProperties_get_groups_count(self.raw.as_ptr()) }
    }

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

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

    /// Iterate the elements, borrowing each in turn.
    pub fn groups_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DataDrivenGroup>> {
        (0..self.groups_len()).map(move |i| self.groups(i).expect("index below len"))
    }

    pub fn resize_groups(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3DataDrivenProperties_resize_groups(self.raw.as_ptr(), count) }
    }
}

impl Default for DataDrivenProperties {
    fn default() -> Self {
        Self::new()
    }
}

/// Outcome of rebuilding a StandardMaterial from a DataDrivenMaterial
///
/// Not every data-driven material has a standard equivalent: some were authored directly against the shader-graph vocabulary, and others are the converted form of a DisplacementMaterial or ReflectionMaterial. `blocker` says which.
///
/// Conversion is lossy even when it succeeds, because the forward direction is: variant fragments collapse onto one layer slot, several fragments are derived from the model rather than the material, and per-field animation links are not carried in the blob. `lossy` lists what was dropped for this material.
pub struct StandardMaterialConversion {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3StandardMaterialConversion>,
}

impl Drop for StandardMaterialConversion {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3StandardMaterialConversion_delete(self.raw.as_ptr()) }
    }
}

impl StandardMaterialConversion {
    /// # 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_M3StandardMaterialConversion,
    ) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| StandardMaterialConversion { 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 StandardMaterialConversion {}

impl core::fmt::Debug for StandardMaterialConversion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("StandardMaterialConversion")
            .finish_non_exhaustive()
    }
}

impl StandardMaterialConversion {
    /// # 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_m3_M3StandardMaterialConversion_new();
            Self::from_raw(raw).expect("native StandardMaterialConversion allocation failed")
        }
    }

    /// Whether `material` was produced
    pub fn converted(&self) -> bool {
        // SAFETY: plain scalar read through a live handle.
        unsafe {
            ffi::whiteout_m3_M3StandardMaterialConversion_get_converted(self.raw.as_ptr()) != 0
        }
    }

    pub fn set_converted(&mut self, value: bool) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3StandardMaterialConversion_set_converted(
                self.raw.as_ptr(),
                if value { 1 } else { 0 },
            )
        }
    }

    /// Why not, when `converted` is false
    pub fn blocker(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3StandardMaterialConversion_get_blocker(
                self.raw.as_ptr(),
            ))
        }
    }

    pub fn set_blocker(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe {
            ffi::whiteout_m3_M3StandardMaterialConversion_set_blocker(
                self.raw.as_ptr(),
                value.as_ptr(),
            )
        }
    }

    /// Only meaningful when `converted`
    /// Borrows the field in place — no copy, no allocation.
    pub fn material(&self) -> crate::support::Ref<'_, StandardMaterial> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(StandardMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3StandardMaterialConversion_get_material(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn material_mut(&mut self) -> crate::support::RefMut<'_, StandardMaterial> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(StandardMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3StandardMaterialConversion_get_material(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for StandardMaterialConversion {
    fn default() -> Self {
        Self::new()
    }
}

/// MADD — Data-driven material (v0–v3, 140–160 bytes)
///
/// The engine's own name for this chunk is `SDataDrivenMaterialData`. It is not "additional" data: at load the renderer converts every StandardMaterial (1), DisplacementMaterial (2) and ReflectionMaterial (10) in the model into one of these and rewrites the MaterialMap to MaterialType::DataDriven, so this is the only material representation the renderer actually consumes.
///
/// `fragmentHashes` names the shader fragments the material links, in order. Concatenating `shaderType`'s token with those names gives the shader permutation name, and its crc32 is the effect-cache lookup key.
///
/// `propertyBlob` is a self-describing two-level dictionary keyed by crc32 of unprefixed names — decode it with decodeProperties().
///
/// @see M3_FILE_FORMAT_SPECIFICATION.md §11 Materials
pub struct DataDrivenMaterial {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3DataDrivenMaterial>,
}

impl Drop for DataDrivenMaterial {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_delete(self.raw.as_ptr()) }
    }
}

impl DataDrivenMaterial {
    /// # 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_M3DataDrivenMaterial) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| DataDrivenMaterial { 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 DataDrivenMaterial {}

impl core::fmt::Debug for DataDrivenMaterial {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("DataDrivenMaterial").finish_non_exhaustive()
    }
}

impl DataDrivenMaterial {
    /// # 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_m3_M3DataDrivenMaterial_new();
            Self::from_raw(raw).expect("native DataDrivenMaterial allocation failed")
        }
    }

    /// Material name (`Ref<CHAR>`)
    pub fn material_name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3DataDrivenMaterial_get_materialName(
                self.raw.as_ptr(),
            ))
        }
    }

    pub fn set_material_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_materialName(
                self.raw.as_ptr(),
                value.as_ptr(),
            )
        }
    }

    /// crc32 of each shader fragment name, in link order (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn fragment_hashes(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_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 fragment_hashes_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_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_fragment_hashes(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_assign_fragmentHashes(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_fragment_hashes(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_resize_fragmentHashes(self.raw.as_ptr(), count)
        }
    }

    /// Secondary hash list (U32_, v2+)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn extra_hashes(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3DataDrivenMaterial_get_extraHashes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenMaterial_get_extraHashes_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 extra_hashes_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3DataDrivenMaterial_get_extraHashes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenMaterial_get_extraHashes_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_extra_hashes(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_assign_extraHashes(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_extra_hashes(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_resize_extraHashes(self.raw.as_ptr(), count)
        }
    }

    /// Property dictionary (`Ref<CHAR>`)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn property_blob(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_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 property_blob_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_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_property_blob(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_assign_propertyBlob(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_property_blob(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_resize_propertyBlob(self.raw.as_ptr(), count)
        }
    }

    /// 1.0, 1.5 or 2.0 across the corpus
    pub fn unknown_108(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown108(self.raw.as_ptr()) }
    }

    pub fn set_unknown_108(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown108(self.raw.as_ptr(), value) }
    }

    /// 1.0 in every known record
    pub fn unknown_112(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown112(self.raw.as_ptr()) }
    }

    pub fn set_unknown_112(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown112(self.raw.as_ptr(), value) }
    }

    pub fn unknown_116(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown116(self.raw.as_ptr()) }
    }

    pub fn set_unknown_116(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown116(self.raw.as_ptr(), value) }
    }

    /// crc32 of the shader permutation name; 0 = compute it at load
    pub fn effect_name_hash(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_effectNameHash(self.raw.as_ptr()) }
    }

    pub fn set_effect_name_hash(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_effectNameHash(self.raw.as_ptr(), value)
        }
    }

    pub fn unknown_124(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown124(self.raw.as_ptr()) }
    }

    pub fn set_unknown_124(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown124(self.raw.as_ptr(), value) }
    }

    /// Zero in every known record
    pub fn padding_128(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_padding128(self.raw.as_ptr()) }
    }

    pub fn set_padding_128(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_padding128(self.raw.as_ptr(), value) }
    }

    pub fn unknown_132(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown132(self.raw.as_ptr()) }
    }

    pub fn set_unknown_132(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown132(self.raw.as_ptr(), value) }
    }

    /// Packed bit field
    pub fn unknown_136(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown136(self.raw.as_ptr()) }
    }

    pub fn set_unknown_136(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown136(self.raw.as_ptr(), value) }
    }

    pub fn unknown_140(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown140(self.raw.as_ptr()) }
    }

    pub fn set_unknown_140(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown140(self.raw.as_ptr(), value) }
    }

    pub fn unknown_144(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown144(self.raw.as_ptr()) }
    }

    pub fn set_unknown_144(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown144(self.raw.as_ptr(), value) }
    }

    pub fn unknown_148(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown148(self.raw.as_ptr()) }
    }

    pub fn set_unknown_148(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown148(self.raw.as_ptr(), value) }
    }

    /// Derived cache the loader recomputes; do not trust over the blob
    pub fn alpha_fresnel_flags(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_alphaFresnelFlags(self.raw.as_ptr()) }
    }

    pub fn set_alpha_fresnel_flags(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_alphaFresnelFlags(self.raw.as_ptr(), value)
        }
    }

    /// Shader family prefix for the permutation name
    pub fn shader_type(&self) -> MaterialShaderType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_shaderType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_shader_type(&mut self, value: MaterialShaderType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_shaderType(self.raw.as_ptr(), value as i32)
        }
    }

    pub fn unknown_151(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_unknown151(self.raw.as_ptr()) }
    }

    pub fn set_unknown_151(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_set_unknown151(self.raw.as_ptr(), value) }
    }

    /// Second permutation hash, 0xFFFFFFFF = none (v3+)
    pub fn effect_name_hash_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_effectNameHash2(self.raw.as_ptr()) }
    }

    pub fn set_effect_name_hash_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_effectNameHash2(self.raw.as_ptr(), value)
        }
    }

    /// Third permutation hash, 0xFFFFFFFF = none (v3+)
    pub fn effect_name_hash_3(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_get_effectNameHash3(self.raw.as_ptr()) }
    }

    pub fn set_effect_name_hash_3(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_set_effectNameHash3(self.raw.as_ptr(), value)
        }
    }

    /// Decode propertyBlob into fragment groups and named properties
    pub fn decode_properties(&self) -> Option<DataDrivenProperties> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            DataDrivenProperties::from_raw(ffi::whiteout_m3_M3DataDrivenMaterial_decodeProperties(
                self.raw.as_ptr(),
            ))
        }
    }

    /// Rebuild the StandardMaterial this was converted from, where possible
    ///
    /// The engine only converts in the other direction, and does so lossily, so this reverses what it can and reports the rest. See StandardMaterialConversion.
    pub fn to_standard_material(&self) -> Option<StandardMaterialConversion> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            StandardMaterialConversion::from_raw(
                ffi::whiteout_m3_M3DataDrivenMaterial_toStandardMaterial(self.raw.as_ptr()),
            )
        }
    }

    /// Best-effort StandardMaterial for a material that has no exact one
    ///
    /// toStandardMaterial() refuses shader-graph materials, which were authored in the node editor and never had a StandardMaterial form. This infers one anyway, from the node types, the per-node names in extraHashes, and the texture filenames. The blob stores nodes but not the edges between them, so the graph topology cannot be recovered and the result is a likeness, not a conversion — `lossy` always says so. Materials that are already fixed-function are forwarded to toStandardMaterial() unchanged.
    pub fn approximate_standard_material(&self) -> Option<StandardMaterialConversion> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            StandardMaterialConversion::from_raw(
                ffi::whiteout_m3_M3DataDrivenMaterial_approximateStandardMaterial(
                    self.raw.as_ptr(),
                ),
            )
        }
    }

    pub fn version(&self) -> i32 {
        // SAFETY: handle is live for the duration of the call.
        unsafe { ffi::whiteout_m3_M3DataDrivenMaterial_getVersion(self.raw.as_ptr()) }
    }

    pub fn set_version(&mut self, new_version: i32) -> bool {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_setVersion(self.raw.as_ptr(), new_version) != 0
        }
    }

    pub fn force_version(&mut self, new_version: i32) {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            ffi::whiteout_m3_M3DataDrivenMaterial_forceVersion(self.raw.as_ptr(), new_version);
        }
    }
}

impl Default for DataDrivenMaterial {
    fn default() -> Self {
        Self::new()
    }
}

/// BONE — Skeleton bone (v0–v1, 160 bytes)
///
/// Each bone has a parent index, animated position/rotation/scale/visibility, and flags controlling inheritance, billboard mode, and IK.
pub struct Bone {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Bone>,
}

impl Drop for Bone {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Bone_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_M3Bone) -> 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_m3_M3Bone_new();
            Self::from_raw(raw).expect("native Bone allocation failed")
        }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_set_unknown(self.raw.as_ptr(), value) }
    }

    /// Bone name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe { crate::support::take_string(ffi::whiteout_m3_M3Bone_get_name(self.raw.as_ptr())) }
    }

    pub fn set_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m3_M3Bone_set_name(self.raw.as_ptr(), value.as_ptr()) }
    }

    /// Bone flags (inherit, billboard, IK, skin)
    pub fn flags(&self) -> BoneFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        BoneFlag(unsafe { ffi::whiteout_m3_M3Bone_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: BoneFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// Parent bone index (0xFFFF = root)
    pub fn parent_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_get_parentIndex(self.raw.as_ptr()) }
    }

    pub fn set_parent_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_set_parentIndex(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Bone_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_m3_M3Bone_set_padding(self.raw.as_ptr(), value) }
    }

    /// Animated translation (36 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn position(&self) -> crate::support::Ref<'_, AnimRefVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_position(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn position_mut(&mut self) -> crate::support::RefMut<'_, AnimRefVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_position(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated rotation (44 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn rotation(&self) -> crate::support::Ref<'_, AnimRefQuaternion> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefQuaternion {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_rotation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn rotation_mut(&mut self) -> crate::support::RefMut<'_, AnimRefQuaternion> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefQuaternion {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_rotation(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated scale (36 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn scale(&self) -> crate::support::Ref<'_, AnimRefVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_scale(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn scale_mut(&mut self) -> crate::support::RefMut<'_, AnimRefVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_scale(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated visibility flag (20 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn visibility(&self) -> crate::support::Ref<'_, AnimRefU32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_visibility(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn visibility_mut(&mut self) -> crate::support::RefMut<'_, AnimRefU32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Bone_get_visibility(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Bone {
    fn default() -> Self {
        Self::new()
    }
}

/// REGN — Region / submesh (v0–v5, 48 bytes)
///
/// Describes a contiguous range of vertices and indices forming a submesh, with bone lookup info for skinning and UV scale/offset for texturing.
pub struct Region {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Region>,
}

impl Drop for Region {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Region_delete(self.raw.as_ptr()) }
    }
}

impl Region {
    /// # 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_M3Region) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Region { 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 Region {}

impl core::fmt::Debug for Region {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Region").finish_non_exhaustive()
    }
}

impl Region {
    /// # 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_m3_M3Region_new();
            Self::from_raw(raw).expect("native Region allocation failed")
        }
    }

    /// Region index
    pub fn index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_index(self.raw.as_ptr()) }
    }

    pub fn set_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_index(self.raw.as_ptr(), value) }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_unknown(self.raw.as_ptr(), value) }
    }

    /// First vertex in the vertex buffer
    pub fn first_vertex(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_firstVertex(self.raw.as_ptr()) }
    }

    pub fn set_first_vertex(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_firstVertex(self.raw.as_ptr(), value) }
    }

    /// Number of vertices
    pub fn vertex_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_vertexCount(self.raw.as_ptr()) }
    }

    pub fn set_vertex_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_vertexCount(self.raw.as_ptr(), value) }
    }

    /// First index in the index buffer
    pub fn first_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_firstIndex(self.raw.as_ptr()) }
    }

    pub fn set_first_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_firstIndex(self.raw.as_ptr(), value) }
    }

    /// Number of indices (triangles × 3)
    pub fn index_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_indexCount(self.raw.as_ptr()) }
    }

    pub fn set_index_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_indexCount(self.raw.as_ptr(), value) }
    }

    /// Repeats boneLookupCount (874 of 874 shipped regions)
    pub fn unknown_2(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_unknown2(self.raw.as_ptr()) }
    }

    pub fn set_unknown_2(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_unknown2(self.raw.as_ptr(), value) }
    }

    /// First entry in bone lookup table
    pub fn first_bone_lookup(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_firstBoneLookup(self.raw.as_ptr()) }
    }

    pub fn set_first_bone_lookup(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_firstBoneLookup(self.raw.as_ptr(), value) }
    }

    /// Number of bone lookup entries
    pub fn bone_lookup_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_boneLookupCount(self.raw.as_ptr()) }
    }

    pub fn set_bone_lookup_count(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_boneLookupCount(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_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_m3_M3Region_set_padding(self.raw.as_ptr(), value) }
    }

    /// Number of bone weight pairs per vertex
    pub fn bone_weight_pairs(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_boneWeightPairs(self.raw.as_ptr()) }
    }

    pub fn set_bone_weight_pairs(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_boneWeightPairs(self.raw.as_ptr(), value) }
    }

    /// Number of bone index pairs per vertex
    pub fn bone_index_pairs(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_boneIndexPairs(self.raw.as_ptr()) }
    }

    pub fn set_bone_index_pairs(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_boneIndexPairs(self.raw.as_ptr(), value) }
    }

    /// Root bone for this region
    pub fn root_bone(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_rootBone(self.raw.as_ptr()) }
    }

    pub fn set_root_bone(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_rootBone(self.raw.as_ptr(), value) }
    }

    /// Region flags (hidden, cloth, etc.)
    pub fn flags(&self) -> RegionFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        RegionFlag(unsafe { ffi::whiteout_m3_M3Region_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: RegionFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// UV coordinate scale factor
    pub fn uv_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_uvScale(self.raw.as_ptr()) }
    }

    pub fn set_uv_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_uvScale(self.raw.as_ptr(), value) }
    }

    /// UV coordinate offset
    pub fn uv_offset(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_get_uvOffset(self.raw.as_ptr()) }
    }

    pub fn set_uv_offset(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Region_set_uvOffset(self.raw.as_ptr(), value) }
    }
}

impl Default for Region {
    fn default() -> Self {
        Self::new()
    }
}

/// BAT_ — Batch / draw call (v0–v1, 14 bytes)
///
/// Associates a Region with a material for rendering. Multiple batches may reference the same region with different materials.
pub struct Batch {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Batch>,
}

impl Drop for Batch {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Batch_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_M3Batch) -> 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_m3_M3Batch_new();
            Self::from_raw(raw).expect("native Batch allocation failed")
        }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_set_unknown(self.raw.as_ptr(), value) }
    }

    /// Index into REGN array
    pub fn region_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_get_regionIndex(self.raw.as_ptr()) }
    }

    pub fn set_region_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_set_regionIndex(self.raw.as_ptr(), value) }
    }

    /// Unknown field
    pub fn unknown_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_get_unknown2(self.raw.as_ptr()) }
    }

    pub fn set_unknown_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_set_unknown2(self.raw.as_ptr(), value) }
    }

    /// Index into MATM material map array
    pub fn material_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_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_m3_M3Batch_set_materialIndex(self.raw.as_ptr(), value) }
    }

    /// Bone whose animated visibility gates this batch's draw (0xFFFF = always drawn). Misnamed — it is a bone index, not a count: the engine's submit loop reads it and skips the batch when that bone is invisible.
    pub fn bone_count(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Batch_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_m3_M3Batch_set_boneCount(self.raw.as_ptr(), value) }
    }
}

impl Default for Batch {
    fn default() -> Self {
        Self::new()
    }
}

/// MSEC — Mesh section bounds (v0–v1, 80 bytes)
///
/// Per-node animated bounding extent used for culling and LOD.
pub struct MeshSection {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3MeshSection>,
}

impl Drop for MeshSection {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3MeshSection_delete(self.raw.as_ptr()) }
    }
}

impl MeshSection {
    /// # 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_M3MeshSection) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| MeshSection { 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 MeshSection {}

impl core::fmt::Debug for MeshSection {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MeshSection").finish_non_exhaustive()
    }
}

impl MeshSection {
    /// # 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_m3_M3MeshSection_new();
            Self::from_raw(raw).expect("native MeshSection allocation failed")
        }
    }

    /// Index into BONE array
    pub fn node_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshSection_get_nodeIndex(self.raw.as_ptr()) }
    }

    pub fn set_node_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshSection_set_nodeIndex(self.raw.as_ptr(), value) }
    }

    /// Animated bounding volume (76 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn bounds(&self) -> crate::support::Ref<'_, AnimRefM3Extent> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefM3Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3MeshSection_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bounds_mut(&mut self) -> crate::support::RefMut<'_, AnimRefM3Extent> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefM3Extent {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3MeshSection_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for MeshSection {
    fn default() -> Self {
        Self::new()
    }
}

/// DIV_ — Mesh division (v0–v2, 52 bytes)
///
/// Top-level mesh container grouping face indices, regions, batches, and mesh sections. Most models have a single division.
pub struct MeshDivision {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3MeshDivision>,
}

impl Drop for MeshDivision {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3MeshDivision_delete(self.raw.as_ptr()) }
    }
}

impl MeshDivision {
    /// # 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_M3MeshDivision) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| MeshDivision { 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 MeshDivision {}

impl core::fmt::Debug for MeshDivision {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MeshDivision").finish_non_exhaustive()
    }
}

impl MeshDivision {
    /// # 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_m3_M3MeshDivision_new();
            Self::from_raw(raw).expect("native MeshDivision allocation failed")
        }
    }

    /// Triangle indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn faces(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3MeshDivision_get_faces_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3MeshDivision_get_faces_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 faces_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3MeshDivision_get_faces_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3MeshDivision_get_faces_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_faces(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3MeshDivision_assign_faces(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_faces(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3MeshDivision_resize_faces(self.raw.as_ptr(), count) }
    }

    /// Regions / submeshes (REGN)
    pub fn regions_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshDivision_get_regions_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn regions(&self, index: usize) -> Option<crate::support::Ref<'_, Region>> {
        if index >= self.regions_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Region {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3MeshDivision_get_regions_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn regions_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Region>> {
        if index >= self.regions_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Region {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3MeshDivision_get_regions_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn regions_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Region>> {
        (0..self.regions_len()).map(move |i| self.regions(i).expect("index below len"))
    }

    pub fn resize_regions(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3MeshDivision_resize_regions(self.raw.as_ptr(), count) }
    }

    /// Draw call batches (BAT_)
    pub fn batches_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshDivision_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_m3_M3MeshDivision_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_m3_M3MeshDivision_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_m3_M3MeshDivision_resize_batches(self.raw.as_ptr(), count) }
    }

    /// Per-node mesh section bounds (MSEC)
    pub fn msec_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshDivision_get_msec_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn msec(&self, index: usize) -> Option<crate::support::Ref<'_, MeshSection>> {
        if index >= self.msec_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(MeshSection {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3MeshDivision_get_msec_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn msec_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, MeshSection>> {
        if index >= self.msec_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(MeshSection {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3MeshDivision_get_msec_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn msec_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, MeshSection>> {
        (0..self.msec_len()).map(move |i| self.msec(i).expect("index below len"))
    }

    pub fn resize_msec(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3MeshDivision_resize_msec(self.raw.as_ptr(), count) }
    }

    /// Instance count
    pub fn instances(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshDivision_get_instances(self.raw.as_ptr()) }
    }

    pub fn set_instances(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3MeshDivision_set_instances(self.raw.as_ptr(), value) }
    }
}

impl Default for MeshDivision {
    fn default() -> Self {
        Self::new()
    }
}

/// IREF — Initial reference / inverse bind-pose (v0, 64 bytes)
///
/// Stores the 4×4 inverse bind-pose matrix for a bone, used to transform vertices from model space into bone-local space for skinning.
pub struct InitialReference {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3InitialReference>,
}

impl Drop for InitialReference {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3InitialReference_delete(self.raw.as_ptr()) }
    }
}

impl InitialReference {
    /// # 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_M3InitialReference) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| InitialReference { 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 InitialReference {}

impl core::fmt::Debug for InitialReference {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("InitialReference").finish_non_exhaustive()
    }
}

impl InitialReference {
    /// # 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_m3_M3InitialReference_new();
            Self::from_raw(raw).expect("native InitialReference allocation failed")
        }
    }
}

impl Default for InitialReference {
    fn default() -> Self {
        Self::new()
    }
}

/// ATT_ — Attachment point (v0–v1, 20 bytes)
///
/// Named bone location used by the engine to attach effects, weapons, or other models to specific skeleton bones.
pub struct AttachmentPoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AttachmentPoint>,
}

impl Drop for AttachmentPoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_delete(self.raw.as_ptr()) }
    }
}

impl AttachmentPoint {
    /// # 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_M3AttachmentPoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AttachmentPoint { 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 AttachmentPoint {}

impl core::fmt::Debug for AttachmentPoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AttachmentPoint").finish_non_exhaustive()
    }
}

impl AttachmentPoint {
    /// # 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_m3_M3AttachmentPoint_new();
            Self::from_raw(raw).expect("native AttachmentPoint allocation failed")
        }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_set_unknown(self.raw.as_ptr(), value) }
    }

    /// Attachment point name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3AttachmentPoint_get_name(
                self.raw.as_ptr(),
            ))
        }
    }

    pub fn set_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_set_name(self.raw.as_ptr(), value.as_ptr()) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentPoint_set_boneIndex(self.raw.as_ptr(), value) }
    }
}

impl Default for AttachmentPoint {
    fn default() -> Self {
        Self::new()
    }
}

/// SSGS — Hit-test shape (v0–v1, 108 bytes)
///
/// Defines a collision / selection volume (box, sphere, capsule, cylinder, or mesh) attached to a bone. Used for both tight and fuzzy hit testing.
pub struct HitTestShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3HitTestShape>,
}

impl Drop for HitTestShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3HitTestShape_delete(self.raw.as_ptr()) }
    }
}

impl HitTestShape {
    /// # 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_M3HitTestShape) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| HitTestShape { 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 HitTestShape {}

impl core::fmt::Debug for HitTestShape {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("HitTestShape").finish_non_exhaustive()
    }
}

impl HitTestShape {
    /// # 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_m3_M3HitTestShape_new();
            Self::from_raw(raw).expect("native HitTestShape allocation failed")
        }
    }

    /// Shape type (box/sphere/capsule/cylinder/mesh). Defaulted because a conversion builds `MODL.tightHitTestObject` without ever assigning it, and an indeterminate enum wrote junk shape types into every export (`reference_m3_layer_stack_junk`, the same defect one field over). Sphere is what 2,222 of 2,448 shipped models state.
    pub fn shape_type(&self) -> HitTestShapeType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3HitTestShape_get_shapeType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_shape_type(&mut self, value: HitTestShapeType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_set_shapeType(self.raw.as_ptr(), value as i32) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_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_m3_M3HitTestShape_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_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_m3_M3HitTestShape_set_padding(self.raw.as_ptr(), value) }
    }

    /// Mesh vertex positions (VEC3, mesh type only)
    /// 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_m3_M3HitTestShape_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3HitTestShape_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_m3_M3HitTestShape_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3HitTestShape_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_m3_M3HitTestShape_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_m3_M3HitTestShape_resize_vertexPositions(self.raw.as_ptr(), count) }
    }

    /// Mesh triangle indices (U16_, mesh type only)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn face_indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3HitTestShape_get_faceIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3HitTestShape_get_faceIndices_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_indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3HitTestShape_get_faceIndices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3HitTestShape_get_faceIndices_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_face_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3HitTestShape_assign_faceIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_face_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3HitTestShape_resize_faceIndices(self.raw.as_ptr(), count) }
    }

    /// X dimension (radius for sphere/capsule)
    pub fn size_x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_get_sizeX(self.raw.as_ptr()) }
    }

    pub fn set_size_x(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_set_sizeX(self.raw.as_ptr(), value) }
    }

    /// Y dimension (height for capsule/cylinder)
    pub fn size_y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_get_sizeY(self.raw.as_ptr()) }
    }

    pub fn set_size_y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_set_sizeY(self.raw.as_ptr(), value) }
    }

    /// Z dimension
    pub fn size_z(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_get_sizeZ(self.raw.as_ptr()) }
    }

    pub fn set_size_z(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3HitTestShape_set_sizeZ(self.raw.as_ptr(), value) }
    }
}

impl Default for HitTestShape {
    fn default() -> Self {
        Self::new()
    }
}

/// ATVL — Attachment volume (v0, 116 bytes)
///
/// Like HitTestShape but with two bone indices for attachment-point volumes.
pub struct AttachmentVolume {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AttachmentVolume>,
}

impl Drop for AttachmentVolume {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_delete(self.raw.as_ptr()) }
    }
}

impl AttachmentVolume {
    /// # 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_M3AttachmentVolume) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AttachmentVolume { 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 AttachmentVolume {}

impl core::fmt::Debug for AttachmentVolume {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AttachmentVolume").finish_non_exhaustive()
    }
}

impl AttachmentVolume {
    /// # 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_m3_M3AttachmentVolume_new();
            Self::from_raw(raw).expect("native AttachmentVolume allocation failed")
        }
    }

    /// First bone index
    pub fn bone_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_bone1(self.raw.as_ptr()) }
    }

    pub fn set_bone_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_set_bone1(self.raw.as_ptr(), value) }
    }

    /// Second bone index
    pub fn bone_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_bone2(self.raw.as_ptr()) }
    }

    pub fn set_bone_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_set_bone2(self.raw.as_ptr(), value) }
    }

    /// Shape type
    pub fn shape_type(&self) -> HitTestShapeType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_shapeType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_shape_type(&mut self, value: HitTestShapeType) {
        // SAFETY: scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3AttachmentVolume_set_shapeType(self.raw.as_ptr(), value as i32)
        }
    }

    /// Primary bone index
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_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_m3_M3AttachmentVolume_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_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_m3_M3AttachmentVolume_set_padding(self.raw.as_ptr(), value) }
    }

    /// Mesh vertex positions (VEC3)
    /// 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_m3_M3AttachmentVolume_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AttachmentVolume_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_m3_M3AttachmentVolume_get_vertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AttachmentVolume_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_m3_M3AttachmentVolume_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_m3_M3AttachmentVolume_resize_vertexPositions(self.raw.as_ptr(), count)
        }
    }

    /// Mesh triangle indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn face_indices(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3AttachmentVolume_get_faceIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AttachmentVolume_get_faceIndices_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_indices_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3AttachmentVolume_get_faceIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3AttachmentVolume_get_faceIndices_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_face_indices(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3AttachmentVolume_assign_faceIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_face_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_resize_faceIndices(self.raw.as_ptr(), count) }
    }

    /// X dimension
    pub fn size_x(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_sizeX(self.raw.as_ptr()) }
    }

    pub fn set_size_x(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_set_sizeX(self.raw.as_ptr(), value) }
    }

    /// Y dimension
    pub fn size_y(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_sizeY(self.raw.as_ptr()) }
    }

    pub fn set_size_y(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_set_sizeY(self.raw.as_ptr(), value) }
    }

    /// Z dimension
    pub fn size_z(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_get_sizeZ(self.raw.as_ptr()) }
    }

    pub fn set_size_z(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AttachmentVolume_set_sizeZ(self.raw.as_ptr(), value) }
    }
}

impl Default for AttachmentVolume {
    fn default() -> Self {
        Self::new()
    }
}

/// TRGD — Trigger data (v0, 24 bytes)
///
/// Named trigger with associated data indices for gameplay events.
pub struct TriggerData {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3TriggerData>,
}

impl Drop for TriggerData {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3TriggerData_delete(self.raw.as_ptr()) }
    }
}

impl TriggerData {
    /// # 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_M3TriggerData) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TriggerData { 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 TriggerData {}

impl core::fmt::Debug for TriggerData {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TriggerData").finish_non_exhaustive()
    }
}

impl TriggerData {
    /// # 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_m3_M3TriggerData_new();
            Self::from_raw(raw).expect("native TriggerData allocation failed")
        }
    }

    /// Data index array (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn data_indices(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3TriggerData_get_dataIndices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3TriggerData_get_dataIndices_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_indices_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3TriggerData_get_dataIndices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3TriggerData_get_dataIndices_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_data_indices(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3TriggerData_assign_dataIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_data_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3TriggerData_resize_dataIndices(self.raw.as_ptr(), count) }
    }

    /// Trigger name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3TriggerData_get_name(self.raw.as_ptr()))
        }
    }

    pub fn set_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m3_M3TriggerData_set_name(self.raw.as_ptr(), value.as_ptr()) }
    }
}

impl Default for TriggerData {
    fn default() -> Self {
        Self::new()
    }
}

/// PATU — Turret behavior (v0–v4, 152 bytes)
///
/// Configures turret rotation constraints for a bone with yaw/pitch limits, weights, and an optional main-turret flag.
pub struct TurretBehavior {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3TurretBehavior>,
}

impl Drop for TurretBehavior {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_delete(self.raw.as_ptr()) }
    }
}

impl TurretBehavior {
    /// # 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_M3TurretBehavior) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TurretBehavior { 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 TurretBehavior {}

impl core::fmt::Debug for TurretBehavior {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TurretBehavior").finish_non_exhaustive()
    }
}

impl TurretBehavior {
    /// # 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_m3_M3TurretBehavior_new();
            Self::from_raw(raw).expect("native TurretBehavior allocation failed")
        }
    }

    /// Unknown vector 1
    pub fn unknown_1(&self) -> crate::math::Vector4f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3TurretBehavior_get_unknown1(self.raw.as_ptr())
                as *const crate::math::Vector4f)
        }
    }

    pub fn set_unknown_1(&mut self, value: crate::math::Vector4f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3TurretBehavior_set_unknown1(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector4f as *const _,
            )
        }
    }

    /// Unknown vector 2
    pub fn unknown_2(&self) -> crate::math::Vector4f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3TurretBehavior_get_unknown2(self.raw.as_ptr())
                as *const crate::math::Vector4f)
        }
    }

    pub fn set_unknown_2(&mut self, value: crate::math::Vector4f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3TurretBehavior_set_unknown2(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector4f as *const _,
            )
        }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_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_m3_M3TurretBehavior_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Non-zero if this is the main turret
    pub fn use_as_main_turret(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_useAsMainTurret(self.raw.as_ptr()) }
    }

    pub fn set_use_as_main_turret(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_useAsMainTurret(self.raw.as_ptr(), value) }
    }

    /// Turret group identifier
    pub fn turret_group_id(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_turretGroupId(self.raw.as_ptr()) }
    }

    pub fn set_turret_group_id(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_turretGroupId(self.raw.as_ptr(), value) }
    }

    /// Enable yaw limits
    pub fn yaw_limited(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_yawLimited(self.raw.as_ptr()) }
    }

    pub fn set_yaw_limited(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_yawLimited(self.raw.as_ptr(), value) }
    }

    /// Minimum yaw angle (radians)
    pub fn yaw_min(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_yawMin(self.raw.as_ptr()) }
    }

    pub fn set_yaw_min(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_yawMin(self.raw.as_ptr(), value) }
    }

    /// Maximum yaw angle (radians)
    pub fn yaw_max(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_yawMax(self.raw.as_ptr()) }
    }

    pub fn set_yaw_max(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_yawMax(self.raw.as_ptr(), value) }
    }

    /// Yaw rotation weight
    pub fn yaw_weight(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_yawWeight(self.raw.as_ptr()) }
    }

    pub fn set_yaw_weight(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_yawWeight(self.raw.as_ptr(), value) }
    }

    /// Enable pitch limits
    pub fn pitch_limited(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_pitchLimited(self.raw.as_ptr()) }
    }

    pub fn set_pitch_limited(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_pitchLimited(self.raw.as_ptr(), value) }
    }

    /// Minimum pitch angle (radians)
    pub fn pitch_min(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_pitchMin(self.raw.as_ptr()) }
    }

    pub fn set_pitch_min(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_pitchMin(self.raw.as_ptr(), value) }
    }

    /// Maximum pitch angle (radians)
    pub fn pitch_max(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_pitchMax(self.raw.as_ptr()) }
    }

    pub fn set_pitch_max(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_pitchMax(self.raw.as_ptr(), value) }
    }

    /// Pitch rotation weight
    pub fn pitch_weight(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_get_pitchWeight(self.raw.as_ptr()) }
    }

    pub fn set_pitch_weight(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_set_pitchWeight(self.raw.as_ptr(), value) }
    }

    /// Unknown field
    pub fn unknown_3(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_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_m3_M3TurretBehavior_set_unknown3(self.raw.as_ptr(), value) }
    }

    /// Unknown field
    pub fn unknown_4(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TurretBehavior_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_m3_M3TurretBehavior_set_unknown4(self.raw.as_ptr(), value) }
    }

    /// Offset from main bone
    pub fn main_bone_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_m3_M3TurretBehavior_get_mainBoneOffset(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_main_bone_offset(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3TurretBehavior_set_mainBoneOffset(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for TurretBehavior {
    fn default() -> Self {
        Self::new()
    }
}

/// BBSC — Billboard behavior (v0, 48 bytes)
///
/// Turns one bone to face the camera. The only source of billboarding there is: `BoneFlag::Billboard1/2` are set on no bone in the whole corpus.
///
/// StarCraft II applies these at draw time, per view, from `sub_10290A890` — `CBBSolver::Solve` is a stub — and writes the bone's *local* rotation, so the subtree follows.
pub struct BillboardBehavior {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3BillboardBehavior>,
}

impl Drop for BillboardBehavior {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_delete(self.raw.as_ptr()) }
    }
}

impl BillboardBehavior {
    /// # 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_M3BillboardBehavior) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| BillboardBehavior { 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 BillboardBehavior {}

impl core::fmt::Debug for BillboardBehavior {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BillboardBehavior").finish_non_exhaustive()
    }
}

impl BillboardBehavior {
    /// # 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_m3_M3BillboardBehavior_new();
            Self::from_raw(raw).expect("native BillboardBehavior allocation failed")
        }
    }

    /// Dependent bone indices (U16_). Empty in every shipped record; the engine never reads them
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3BillboardBehavior_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3BillboardBehavior_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3BillboardBehavior_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3BillboardBehavior_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3BillboardBehavior_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_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_m3_M3BillboardBehavior_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Which axes may turn — see BillboardType
    pub fn billboard_type(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_get_billboardType(self.raw.as_ptr()) }
    }

    pub fn set_billboard_type(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_set_billboardType(self.raw.as_ptr(), value) }
    }

    /// Non-zero: aim from this bone at the eye. Zero: aim along the camera's view direction instead, so every such bone shares one orientation
    pub fn camera_look_at(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_get_cameraLookAt(self.raw.as_ptr()) }
    }

    pub fn set_camera_look_at(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3BillboardBehavior_set_cameraLookAt(self.raw.as_ptr(), value) }
    }

    /// MISNAMED: not a direction. A rotation applied *before* the billboard basis, and only by the axis-locked types 0/1/2
    pub fn up(&self) -> crate::math::Quaternion {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3BillboardBehavior_get_up(self.raw.as_ptr())
                as *const crate::math::Quaternion)
        }
    }

    pub fn set_up(&mut self, value: crate::math::Quaternion) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3BillboardBehavior_set_up(
                self.raw.as_ptr(),
                &value as *const crate::math::Quaternion as *const _,
            )
        }
    }

    /// MISNAMED likewise: the same kind of pre-rotation, taken only by type 6, and only on a bone whose parent is another bone. Types 3/4/5 take neither
    pub fn forward(&self) -> crate::math::Quaternion {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3BillboardBehavior_get_forward(self.raw.as_ptr())
                as *const crate::math::Quaternion)
        }
    }

    pub fn set_forward(&mut self, value: crate::math::Quaternion) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3BillboardBehavior_set_forward(
                self.raw.as_ptr(),
                &value as *const crate::math::Quaternion as *const _,
            )
        }
    }
}

impl Default for BillboardBehavior {
    fn default() -> Self {
        Self::new()
    }
}

/// IKJT — IK joint (v0, 32 bytes)
///
/// Inverse kinematics joint with raycast up/down range, max speed, and goal threshold for terrain-following or foot-planting.
pub struct IKJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3IKJoint>,
}

impl Drop for IKJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3IKJoint_delete(self.raw.as_ptr()) }
    }
}

impl IKJoint {
    /// # 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_M3IKJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| IKJoint { 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 IKJoint {}

impl core::fmt::Debug for IKJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("IKJoint").finish_non_exhaustive()
    }
}

impl IKJoint {
    /// # 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_m3_M3IKJoint_new();
            Self::from_raw(raw).expect("native IKJoint allocation failed")
        }
    }

    /// Dependent bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3IKJoint_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3IKJoint_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3IKJoint_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3IKJoint_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3IKJoint_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3IKJoint_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// First bone index
    pub fn bone_index_1(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_boneIndex1(self.raw.as_ptr()) }
    }

    pub fn set_bone_index_1(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_boneIndex1(self.raw.as_ptr(), value) }
    }

    /// Second bone index
    pub fn bone_index_2(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_boneIndex2(self.raw.as_ptr()) }
    }

    pub fn set_bone_index_2(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_boneIndex2(self.raw.as_ptr(), value) }
    }

    /// Raycast upward distance (positive; shipped 1.5 / 3.0)
    pub fn raycast_up(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_raycastUp(self.raw.as_ptr()) }
    }

    pub fn set_raycast_up(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_raycastUp(self.raw.as_ptr(), value) }
    }

    /// Raycast downward offset, SIGNED (shipped -4.0 / -3.0): the surface window is [z + raycastDown, z + raycastUp]
    pub fn raycast_down(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_raycastDown(self.raw.as_ptr()) }
    }

    pub fn set_raycast_down(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_raycastDown(self.raw.as_ptr(), value) }
    }

    /// Maximum IK solving speed
    pub fn max_speed(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_maxSpeed(self.raw.as_ptr()) }
    }

    pub fn set_max_speed(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_maxSpeed(self.raw.as_ptr(), value) }
    }

    /// Goal distance threshold
    pub fn goal_threshold(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_get_goalThreshold(self.raw.as_ptr()) }
    }

    pub fn set_goal_threshold(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKJoint_set_goalThreshold(self.raw.as_ptr(), value) }
    }
}

impl Default for IKJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// IK2J — Two-joint IK solver (v0, 48 bytes)
///
/// Classic two-bone IK (e.g. elbow/knee) with hinge axis, angle limits, and search range for target acquisition.
pub struct IKTwoJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3IKTwoJoint>,
}

impl Drop for IKTwoJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_delete(self.raw.as_ptr()) }
    }
}

impl IKTwoJoint {
    /// # 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_M3IKTwoJoint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| IKTwoJoint { 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 IKTwoJoint {}

impl core::fmt::Debug for IKTwoJoint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("IKTwoJoint").finish_non_exhaustive()
    }
}

impl IKTwoJoint {
    /// # 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_m3_M3IKTwoJoint_new();
            Self::from_raw(raw).expect("native IKTwoJoint allocation failed")
        }
    }

    /// Dependent bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3IKTwoJoint_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3IKTwoJoint_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3IKTwoJoint_get_dependents_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3IKTwoJoint_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3IKTwoJoint_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// Base bone (e.g. upper arm/thigh)
    pub fn bone_base(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_boneBase(self.raw.as_ptr()) }
    }

    pub fn set_bone_base(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_boneBase(self.raw.as_ptr(), value) }
    }

    /// Target bone (e.g. forearm/shin)
    pub fn bone_target(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_boneTarget(self.raw.as_ptr()) }
    }

    pub fn set_bone_target(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_boneTarget(self.raw.as_ptr(), value) }
    }

    /// End effector bone (e.g. hand/foot)
    pub fn bone_end(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_boneEnd(self.raw.as_ptr()) }
    }

    pub fn set_bone_end(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_boneEnd(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_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_m3_M3IKTwoJoint_set_padding(self.raw.as_ptr(), value) }
    }

    /// Hinge rotation axis
    pub fn hinge_axis(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3IKTwoJoint_get_hingeAxis(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_hinge_axis(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3IKTwoJoint_set_hingeAxis(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Maximum inner angle
    pub fn max_angle_inner(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_maxAngleInner(self.raw.as_ptr()) }
    }

    pub fn set_max_angle_inner(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_maxAngleInner(self.raw.as_ptr(), value) }
    }

    /// Maximum outer angle
    pub fn max_angle_outer(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_maxAngleOuter(self.raw.as_ptr()) }
    }

    pub fn set_max_angle_outer(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_maxAngleOuter(self.raw.as_ptr(), value) }
    }

    /// Search range upward
    pub fn search_up(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_searchUp(self.raw.as_ptr()) }
    }

    pub fn set_search_up(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_searchUp(self.raw.as_ptr(), value) }
    }

    /// Search range downward
    pub fn search_down(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_get_searchDown(self.raw.as_ptr()) }
    }

    pub fn set_search_down(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKTwoJoint_set_searchDown(self.raw.as_ptr(), value) }
    }
}

impl Default for IKTwoJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// IKCC — CCD IK solver (v0, 24 bytes)
///
/// Cyclic Coordinate Descent IK solver with base/target bones and vertical search range.
pub struct IKCCD {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3IKCCD>,
}

impl Drop for IKCCD {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3IKCCD_delete(self.raw.as_ptr()) }
    }
}

impl IKCCD {
    /// # 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_M3IKCCD) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| IKCCD { 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 IKCCD {}

impl core::fmt::Debug for IKCCD {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("IKCCD").finish_non_exhaustive()
    }
}

impl IKCCD {
    /// # 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_m3_M3IKCCD_new();
            Self::from_raw(raw).expect("native IKCCD allocation failed")
        }
    }

    /// Dependent bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3IKCCD_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3IKCCD_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3IKCCD_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3IKCCD_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3IKCCD_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3IKCCD_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// Base bone index
    pub fn bone_base(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_get_boneBase(self.raw.as_ptr()) }
    }

    pub fn set_bone_base(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_set_boneBase(self.raw.as_ptr(), value) }
    }

    /// Target bone index
    pub fn bone_target(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_get_boneTarget(self.raw.as_ptr()) }
    }

    pub fn set_bone_target(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_set_boneTarget(self.raw.as_ptr(), value) }
    }

    /// Search range upward
    pub fn search_up(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_get_searchUp(self.raw.as_ptr()) }
    }

    pub fn set_search_up(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_set_searchUp(self.raw.as_ptr(), value) }
    }

    /// Search range downward
    pub fn search_down(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_get_searchDown(self.raw.as_ptr()) }
    }

    pub fn set_search_down(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3IKCCD_set_searchDown(self.raw.as_ptr(), value) }
    }
}

impl Default for IKCCD {
    fn default() -> Self {
        Self::new()
    }
}

/// PAOB — One-bone IK solver (v0, 24 bytes)
///
/// Simple single-bone orientation solver with angle limit and fallback bone.
pub struct OneBoneSolver {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3OneBoneSolver>,
}

impl Drop for OneBoneSolver {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_delete(self.raw.as_ptr()) }
    }
}

impl OneBoneSolver {
    /// # 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_M3OneBoneSolver) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| OneBoneSolver { 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 OneBoneSolver {}

impl core::fmt::Debug for OneBoneSolver {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("OneBoneSolver").finish_non_exhaustive()
    }
}

impl OneBoneSolver {
    /// # 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_m3_M3OneBoneSolver_new();
            Self::from_raw(raw).expect("native OneBoneSolver allocation failed")
        }
    }

    /// Dependent bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3OneBoneSolver_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3OneBoneSolver_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3OneBoneSolver_get_dependents_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3OneBoneSolver_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3OneBoneSolver_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// Primary bone index
    pub fn bone(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_get_bone(self.raw.as_ptr()) }
    }

    pub fn set_bone(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_set_bone(self.raw.as_ptr(), value) }
    }

    /// Fallback bone index
    pub fn bone_fallback(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_get_boneFallback(self.raw.as_ptr()) }
    }

    pub fn set_bone_fallback(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_set_boneFallback(self.raw.as_ptr(), value) }
    }

    /// Maximum rotation angle
    pub fn max_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_get_maxAngle(self.raw.as_ptr()) }
    }

    pub fn set_max_angle(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3OneBoneSolver_set_maxAngle(self.raw.as_ptr(), value) }
    }
}

impl Default for OneBoneSolver {
    fn default() -> Self {
        Self::new()
    }
}

/// SHBX — Shadow box (v0, 64 bytes)
///
/// Axis-aligned shadow volume defined by a 4×4 transform matrix.
pub struct ShadowBox {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ShadowBox>,
}

impl Drop for ShadowBox {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ShadowBox_delete(self.raw.as_ptr()) }
    }
}

impl ShadowBox {
    /// # 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_M3ShadowBox) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ShadowBox { 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 ShadowBox {}

impl core::fmt::Debug for ShadowBox {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ShadowBox").finish_non_exhaustive()
    }
}

impl ShadowBox {
    /// # 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_m3_M3ShadowBox_new();
            Self::from_raw(raw).expect("native ShadowBox allocation failed")
        }
    }
}

impl Default for ShadowBox {
    fn default() -> Self {
        Self::new()
    }
}

/// VVOL — View volume (v0, 40 bytes)
///
/// Animated visibility volume bound to a bone, used for culling decisions.
pub struct ViewVolume {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ViewVolume>,
}

impl Drop for ViewVolume {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ViewVolume_delete(self.raw.as_ptr()) }
    }
}

impl ViewVolume {
    /// # 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_M3ViewVolume) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ViewVolume { 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 ViewVolume {}

impl core::fmt::Debug for ViewVolume {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ViewVolume").finish_non_exhaustive()
    }
}

impl ViewVolume {
    /// # 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_m3_M3ViewVolume_new();
            Self::from_raw(raw).expect("native ViewVolume allocation failed")
        }
    }

    /// Index into BONE array
    pub fn node_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ViewVolume_get_nodeIndex(self.raw.as_ptr()) }
    }

    pub fn set_node_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ViewVolume_set_nodeIndex(self.raw.as_ptr(), value) }
    }

    /// Animated half-extents (36 bytes)
    /// Borrows the field in place — no copy, no allocation.
    pub fn size(&self) -> crate::support::Ref<'_, AnimRefVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3ViewVolume_get_size(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn size_mut(&mut self) -> crate::support::RefMut<'_, AnimRefVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3ViewVolume_get_size(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for ViewVolume {
    fn default() -> Self {
        Self::new()
    }
}

/// TMD_ — Trailing model (v0–v1, defunct)
///
/// Legacy trailing model data. Observed in older files but no longer actively used by the engine.
pub struct TrailingModel {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3TrailingModel>,
}

impl Drop for TrailingModel {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3TrailingModel_delete(self.raw.as_ptr()) }
    }
}

impl TrailingModel {
    /// # 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_M3TrailingModel) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| TrailingModel { 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 TrailingModel {}

impl core::fmt::Debug for TrailingModel {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("TrailingModel").finish_non_exhaustive()
    }
}

impl TrailingModel {
    /// # 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_m3_M3TrailingModel_new();
            Self::from_raw(raw).expect("native TrailingModel allocation failed")
        }
    }

    /// Control vectors (VEC3)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn vectors(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3TrailingModel_get_vectors_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3TrailingModel_get_vectors_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 vectors_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3TrailingModel_get_vectors_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3TrailingModel_get_vectors_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_vectors(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3TrailingModel_assign_vectors(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vectors(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3TrailingModel_resize_vectors(self.raw.as_ptr(), count) }
    }

    /// Parameter 0 (observed: 5.0)
    pub fn param_0(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_get_param0(self.raw.as_ptr()) }
    }

    pub fn set_param_0(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_set_param0(self.raw.as_ptr(), value) }
    }

    /// Parameter 1 (observed: 1.0)
    pub fn param_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_get_param1(self.raw.as_ptr()) }
    }

    pub fn set_param_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_set_param1(self.raw.as_ptr(), value) }
    }

    /// Animated float 0 (init 0.5)
    /// Borrows the field in place — no copy, no allocation.
    pub fn anim_float_0(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3TrailingModel_get_animFloat0(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn anim_float_0_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3TrailingModel_get_animFloat0(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated float 1 (init 1.0)
    /// Borrows the field in place — no copy, no allocation.
    pub fn anim_float_1(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3TrailingModel_get_animFloat1(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn anim_float_1_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3TrailingModel_get_animFloat1(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Flag (observed: 1)
    pub fn flag(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_get_flag(self.raw.as_ptr()) }
    }

    pub fn set_flag(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_set_flag(self.raw.as_ptr(), value) }
    }

    /// Reserved
    pub fn reserved_0(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_get_reserved0(self.raw.as_ptr()) }
    }

    pub fn set_reserved_0(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_set_reserved0(self.raw.as_ptr(), value) }
    }

    /// Reserved
    pub fn reserved_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_get_reserved1(self.raw.as_ptr()) }
    }

    pub fn set_reserved_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3TrailingModel_set_reserved1(self.raw.as_ptr(), value) }
    }
}

impl Default for TrailingModel {
    fn default() -> Self {
        Self::new()
    }
}

/// FOR_ — Force field (v0–v2, 104 bytes)
///
/// Applies radial, wind, or explosion forces to particles and ribbons within an influence volume shape (sphere, cylinder, box, hemisphere).
pub struct Force {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Force>,
}

impl Drop for Force {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Force_delete(self.raw.as_ptr()) }
    }
}

impl Force {
    /// # 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_M3Force) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Force { 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 Force {}

impl core::fmt::Debug for Force {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Force").finish_non_exhaustive()
    }
}

impl Force {
    /// # 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_m3_M3Force_new();
            Self::from_raw(raw).expect("native Force allocation failed")
        }
    }

    /// Force influence type (radial/wind/explosion)
    pub fn force_type(&self) -> ForceType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3Force_get_forceType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_force_type(&mut self, value: ForceType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_forceType(self.raw.as_ptr(), value as i32) }
    }

    /// Influence volume shape
    pub fn force_shape(&self) -> ForceShape {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3Force_get_forceShape(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_force_shape(&mut self, value: ForceShape) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_forceShape(self.raw.as_ptr(), value as i32) }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_unknown(self.raw.as_ptr(), value) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Force flags (falloff, height gradient, unbounded)
    pub fn flags(&self) -> ForceFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        ForceFlag(unsafe { ffi::whiteout_m3_M3Force_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: ForceFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// Local channel bitmask
    pub fn local_channels(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_get_localChannels(self.raw.as_ptr()) }
    }

    pub fn set_local_channels(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Force_set_localChannels(self.raw.as_ptr(), value) }
    }

    /// Animated force strength
    /// Borrows the field in place — no copy, no allocation.
    pub fn strength(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_strength(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn strength_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_strength(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated influence width
    /// Borrows the field in place — no copy, no allocation.
    pub fn width(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_width(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn width_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_width(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated influence height
    /// Borrows the field in place — no copy, no allocation.
    pub fn height(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_height(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn height_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_height(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated influence length
    /// Borrows the field in place — no copy, no allocation.
    pub fn length(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_length(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn length_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Force_get_length(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Force {
    fn default() -> Self {
        Self::new()
    }
}

/// WRP_ — Warp field (v0–v1, 132 bytes)
///
/// Warps particle/ribbon trajectories with animated radius, height, and angular/axial/radial strength components.
pub struct Warp {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Warp>,
}

impl Drop for Warp {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Warp_delete(self.raw.as_ptr()) }
    }
}

impl Warp {
    /// # 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_M3Warp) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| Warp { 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 Warp {}

impl core::fmt::Debug for Warp {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Warp").finish_non_exhaustive()
    }
}

impl Warp {
    /// # 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_m3_M3Warp_new();
            Self::from_raw(raw).expect("native Warp allocation failed")
        }
    }

    /// Warp type
    pub fn warp_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_get_warpType(self.raw.as_ptr()) }
    }

    pub fn set_warp_type(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_set_warpType(self.raw.as_ptr(), value) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Unknown field
    pub fn unknown(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_get_unknown(self.raw.as_ptr()) }
    }

    pub fn set_unknown(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Warp_set_unknown(self.raw.as_ptr(), value) }
    }

    /// Animated warp radius
    /// Borrows the field in place — no copy, no allocation.
    pub fn radius(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_radius(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn radius_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_radius(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated warp height
    /// Borrows the field in place — no copy, no allocation.
    pub fn height(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_height(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn height_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_height(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated warp strength
    /// Borrows the field in place — no copy, no allocation.
    pub fn strength(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_strength(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn strength_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_strength(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated angular component
    /// Borrows the field in place — no copy, no allocation.
    pub fn angular(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_angular(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn angular_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_angular(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated axial component
    /// Borrows the field in place — no copy, no allocation.
    pub fn axial(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_axial(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn axial_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_axial(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated radial component
    /// Borrows the field in place — no copy, no allocation.
    pub fn radial(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_radial(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn radial_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Warp_get_radial(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Warp {
    fn default() -> Self {
        Self::new()
    }
}

/// DMSE — Convex hull half-edge (v0, 4 bytes)
///
/// Half-edge connectivity for PHSH convex hull shapes (shapeType = 4). Entries are stored in consecutive twin pairs (forward 0x01 / reverse 0xFF). The nextAroundVertex field chains half-edges into closed per-vertex rings.
pub struct ConvexHullHalfEdge {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ConvexHullHalfEdge>,
}

impl Drop for ConvexHullHalfEdge {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_delete(self.raw.as_ptr()) }
    }
}

impl ConvexHullHalfEdge {
    /// # 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_M3ConvexHullHalfEdge) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ConvexHullHalfEdge { 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 ConvexHullHalfEdge {}

impl core::fmt::Debug for ConvexHullHalfEdge {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ConvexHullHalfEdge").finish_non_exhaustive()
    }
}

impl ConvexHullHalfEdge {
    /// # 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_m3_M3ConvexHullHalfEdge_new();
            Self::from_raw(raw).expect("native ConvexHullHalfEdge allocation failed")
        }
    }

    /// 0x01 = forward, 0xFF = reverse (twin)
    pub fn type_(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_get_type(self.raw.as_ptr()) }
    }

    pub fn set_type_(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_set_type(self.raw.as_ptr(), value) }
    }

    /// Face this half-edge borders
    pub fn face_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_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_m3_M3ConvexHullHalfEdge_set_faceIndex(self.raw.as_ptr(), value) }
    }

    /// Target vertex of this half-edge
    pub fn vertex_index(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_get_vertexIndex(self.raw.as_ptr()) }
    }

    pub fn set_vertex_index(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_set_vertexIndex(self.raw.as_ptr(), value) }
    }

    /// Next half-edge around the same vertex
    pub fn next_around_vertex(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ConvexHullHalfEdge_get_nextAroundVertex(self.raw.as_ptr()) }
    }

    pub fn set_next_around_vertex(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3ConvexHullHalfEdge_set_nextAroundVertex(self.raw.as_ptr(), value)
        }
    }
}

impl Default for ConvexHullHalfEdge {
    fn default() -> Self {
        Self::new()
    }
}

/// DMMN — Physics mesh BVH node (v0: 12 bytes, v1: 8 bytes)
///
/// DMMN entries form a linearized k-DOP Bounding Volume Hierarchy (BVH) tree for concave mesh collision. The entry count is always odd: n = 2*n_leaves - 1.
///
/// **Tree structure** — right-skewed binary tree stored in DFS preorder: - Array layout: (INT_0, LEAF_1), (INT_2, LEAF_3), ..., LEAF_{n-1} - Even indices 0..n-3: internal nodes - Odd indices 1..n-2: leaf nodes - Last index n-1: leaf node - Each internal node 2k: left child = leaf 2k+1, right child = node 2k+2
///
/// **v0** (Havok-era, 12 bytes per node) — stores only the slab normal direction as a plain Vector3f. No quantized slab bounds are present; the tree topology and bounding-slab directions are identical to v1, but distance culling relies on the runtime computing slab projections against meshBoundsCenter/Extent. Only 3 files in the corpus use v0 (all with PHSH v2).
///
/// **v1** (Domino physics, 8 bytes per node) — octahedral-encoded normal + quantized slab bounds: - i16 octX, octY: octahedral-mapped slab normal (snorm16 pair) - u16 slabMin, slabMax: quantized bounding-slab distances along the normal - Internal nodes: slabMax != 0; leaf sentinel: slabMax == 0 (except the last node, which may have slabMax != 0 despite being a leaf)
///
/// **Quantization** (v1, universally confirmed across 468 corpus files): - Per-axis step: tol_i = extent_i / 32767 - Projected step: tol_proj = dot(tolerance, |normal|) - Slab values quantized as: q = round(projection / tol_proj) - Root node slab range approaches [-32767, +32767] (full AABB)
///
/// Internal nodes use one slab direction; their paired leaf uses a DIFFERENT slab direction, forming a 2-DOP bound per primitive group. Most trees (391/468) use multiple slab normals across internal levels for tighter culling.
///
/// PHSH meshTreeDepth gives the tree height (longest root-to-leaf path in nodes).
pub struct PhysicsMeshBvhNode {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsMeshBvhNode>,
}

impl Drop for PhysicsMeshBvhNode {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshBvhNode_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsMeshBvhNode {
    /// # 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_M3PhysicsMeshBvhNode) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsMeshBvhNode { 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 PhysicsMeshBvhNode {}

impl core::fmt::Debug for PhysicsMeshBvhNode {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsMeshBvhNode").finish_non_exhaustive()
    }
}

impl PhysicsMeshBvhNode {
    /// # 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_m3_M3PhysicsMeshBvhNode_new();
            Self::from_raw(raw).expect("native PhysicsMeshBvhNode allocation failed")
        }
    }
}

impl Default for PhysicsMeshBvhNode {
    fn default() -> Self {
        Self::new()
    }
}

/// DMMT — Physics mesh triangle (v0, 28 bytes)
pub struct PhysicsMeshTriangle {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsMeshTriangle>,
}

impl Drop for PhysicsMeshTriangle {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsMeshTriangle {
    /// # 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_M3PhysicsMeshTriangle) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsMeshTriangle { 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 PhysicsMeshTriangle {}

impl core::fmt::Debug for PhysicsMeshTriangle {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsMeshTriangle")
            .finish_non_exhaustive()
    }
}

impl PhysicsMeshTriangle {
    /// # 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_m3_M3PhysicsMeshTriangle_new();
            Self::from_raw(raw).expect("native PhysicsMeshTriangle allocation failed")
        }
    }

    /// First vertex index
    pub fn vertex_index_0(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex0(self.raw.as_ptr()) }
    }

    pub fn set_vertex_index_0(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex0(self.raw.as_ptr(), value) }
    }

    /// Second vertex index
    pub fn vertex_index_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex1(self.raw.as_ptr()) }
    }

    pub fn set_vertex_index_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex1(self.raw.as_ptr(), value) }
    }

    /// Third vertex index
    pub fn vertex_index_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex2(self.raw.as_ptr()) }
    }

    pub fn set_vertex_index_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex2(self.raw.as_ptr(), value) }
    }

    /// First edge index
    pub fn edge_index_0(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex0(self.raw.as_ptr()) }
    }

    pub fn set_edge_index_0(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex0(self.raw.as_ptr(), value) }
    }

    /// Second edge index
    pub fn edge_index_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex1(self.raw.as_ptr()) }
    }

    pub fn set_edge_index_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex1(self.raw.as_ptr(), value) }
    }

    /// Third edge index
    pub fn edge_index_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex2(self.raw.as_ptr()) }
    }

    pub fn set_edge_index_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex2(self.raw.as_ptr(), value) }
    }

    /// Reserved
    pub fn reserved(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_get_reserved(self.raw.as_ptr()) }
    }

    pub fn set_reserved(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_set_reserved(self.raw.as_ptr(), value) }
    }

    /// Triangle flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshTriangle_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_m3_M3PhysicsMeshTriangle_set_flags(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsMeshTriangle {
    fn default() -> Self {
        Self::new()
    }
}

/// DMME — Physics mesh edge (v0, 20 bytes)
pub struct PhysicsMeshEdge {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsMeshEdge>,
}

impl Drop for PhysicsMeshEdge {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsMeshEdge {
    /// # 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_M3PhysicsMeshEdge) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsMeshEdge { 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 PhysicsMeshEdge {}

impl core::fmt::Debug for PhysicsMeshEdge {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsMeshEdge").finish_non_exhaustive()
    }
}

impl PhysicsMeshEdge {
    /// # 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_m3_M3PhysicsMeshEdge_new();
            Self::from_raw(raw).expect("native PhysicsMeshEdge allocation failed")
        }
    }

    /// Edge type
    pub fn edge_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_get_edgeType(self.raw.as_ptr()) }
    }

    pub fn set_edge_type(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_set_edgeType(self.raw.as_ptr(), value) }
    }

    /// First vertex index
    pub fn vertex_a(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_get_vertexA(self.raw.as_ptr()) }
    }

    pub fn set_vertex_a(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_set_vertexA(self.raw.as_ptr(), value) }
    }

    /// Second vertex index
    pub fn vertex_b(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_get_vertexB(self.raw.as_ptr()) }
    }

    pub fn set_vertex_b(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_set_vertexB(self.raw.as_ptr(), value) }
    }

    /// First adjacent face
    pub fn face_a(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_get_faceA(self.raw.as_ptr()) }
    }

    pub fn set_face_a(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_set_faceA(self.raw.as_ptr(), value) }
    }

    /// Second adjacent face
    pub fn face_b(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_get_faceB(self.raw.as_ptr()) }
    }

    pub fn set_face_b(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsMeshEdge_set_faceB(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsMeshEdge {
    fn default() -> Self {
        Self::new()
    }
}

/// PHSH — Physics shape (v0–v3, 132/292/300 bytes)
///
/// The 300-byte v3 layout is a three-part union. Bytes 0–79 are the common header. Bytes 80–103 hold shape dimensions for simple shapes (0–3) or are zero for complex shapes. Bytes 80–183 form the convex hull section (shapeType 4); bytes 184–299 form the mesh section (shapeType 5).
///
/// v2 shares the v3 layout through the hull section but has a shorter mesh section (292 bytes total): bounds/tolerance, four legacy geometry refs, then a 6-dword tail (unknown, vertexCount, faceCount, 2× unknown, treeDepth) — verified against the SC2 client's version-upgrade copier.
pub struct PhysicsShape {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsShape>,
}

impl Drop for PhysicsShape {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_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_M3PhysicsShape) -> 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_m3_M3PhysicsShape_new();
            Self::from_raw(raw).expect("native PhysicsShape allocation failed")
        }
    }

    /// Havok convex radius (v1 only, ≈ 0.019685)
    pub fn collision_margin(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_collisionMargin(self.raw.as_ptr()) }
    }

    pub fn set_collision_margin(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_collisionMargin(self.raw.as_ptr(), value) }
    }

    /// Shape type (box/sphere/capsule/cylinder/hull/mesh)
    pub fn shape_type(&self) -> PhysicsShapeType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_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_m3_M3PhysicsShape_set_shapeType(self.raw.as_ptr(), value as i32) }
    }

    /// Legacy sizes (v1 only, zero for shapeType 4–5)
    pub fn old_sizes(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_oldSizes(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_old_sizes(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_oldSizes(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Shape dimensions (v2+, zero for complex shapes)
    pub fn shape_dimensions(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_shapeDimensions(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_shape_dimensions(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_shapeDimensions(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Per-face unit normals (VEC3)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn hull_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_m3_M3PhysicsShape_get_hullFaceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_hullFaceNormals_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 hull_face_normals_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3PhysicsShape_get_hullFaceNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_hullFaceNormals_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_hull_face_normals(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_assign_hullFaceNormals(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_hull_face_normals(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_resize_hullFaceNormals(self.raw.as_ptr(), count) }
    }

    /// Vertex positions, w=0 (VEC4)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn hull_vertex_positions(&self) -> &[crate::math::Vector4f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_hullVertexPositions_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 hull_vertex_positions_mut(&mut self) -> &mut [crate::math::Vector4f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_hullVertexPositions_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_hull_vertex_positions(&mut self, values: &[crate::math::Vector4f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_assign_hullVertexPositions(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_hull_vertex_positions(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_resize_hullVertexPositions(self.raw.as_ptr(), count)
        }
    }

    /// Half-edge table (DMSE)
    pub fn hull_half_edges_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullHalfEdges_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn hull_half_edges(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, ConvexHullHalfEdge>> {
        if index >= self.hull_half_edges_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ConvexHullHalfEdge {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3PhysicsShape_get_hullHalfEdges_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn hull_half_edges_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ConvexHullHalfEdge>> {
        if index >= self.hull_half_edges_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ConvexHullHalfEdge {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3PhysicsShape_get_hullHalfEdges_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn hull_half_edges_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ConvexHullHalfEdge>> {
        (0..self.hull_half_edges_len())
            .map(move |i| self.hull_half_edges(i).expect("index below len"))
    }

    pub fn resize_hull_half_edges(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_resize_hullHalfEdges(self.raw.as_ptr(), count) }
    }

    /// One face index per vertex (U8__)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn hull_vertex_face_indices(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_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 hull_vertex_face_indices_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_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_hull_vertex_face_indices(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_assign_hullVertexFaceIndices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_hull_vertex_face_indices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_resize_hullVertexFaceIndices(self.raw.as_ptr(), count)
        }
    }

    /// Hull centroid
    pub fn hull_center(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_hullCenter(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_hull_center(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_hullCenter(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Number of face normals
    pub fn hull_face_normal_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullFaceNormalCount(self.raw.as_ptr()) }
    }

    pub fn set_hull_face_normal_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_hullFaceNormalCount(self.raw.as_ptr(), value) }
    }

    /// Number of vertices
    pub fn hull_vertex_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullVertexCount(self.raw.as_ptr()) }
    }

    pub fn set_hull_vertex_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_hullVertexCount(self.raw.as_ptr(), value) }
    }

    /// Number of half-edges
    pub fn hull_half_edge_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullHalfEdgeCount(self.raw.as_ptr()) }
    }

    pub fn set_hull_half_edge_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_hullHalfEdgeCount(self.raw.as_ptr(), value) }
    }

    /// Unknown hull parameter 0
    pub fn hull_unknown_0(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullUnknown0(self.raw.as_ptr()) }
    }

    pub fn set_hull_unknown_0(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_hullUnknown0(self.raw.as_ptr(), value) }
    }

    /// Unknown hull parameter 1
    pub fn hull_unknown_1(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_hullUnknown1(self.raw.as_ptr()) }
    }

    pub fn set_hull_unknown_1(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_hullUnknown1(self.raw.as_ptr(), value) }
    }

    /// BVH tree nodes (DMMN)
    pub fn mesh_bvh_nodes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshBvhNodes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn mesh_bvh_nodes(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, PhysicsMeshBvhNode>> {
        if index >= self.mesh_bvh_nodes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsMeshBvhNode {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3PhysicsShape_get_meshBvhNodes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn mesh_bvh_nodes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PhysicsMeshBvhNode>> {
        if index >= self.mesh_bvh_nodes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsMeshBvhNode {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3PhysicsShape_get_meshBvhNodes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn mesh_bvh_nodes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsMeshBvhNode>> {
        (0..self.mesh_bvh_nodes_len())
            .map(move |i| self.mesh_bvh_nodes(i).expect("index below len"))
    }

    pub fn resize_mesh_bvh_nodes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_resize_meshBvhNodes(self.raw.as_ptr(), count) }
    }

    /// Vertex positions, w=0 (VEC4)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn mesh_vertex_positions(&self) -> &[crate::math::Vector4f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_meshVertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_meshVertexPositions_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 mesh_vertex_positions_mut(&mut self) -> &mut [crate::math::Vector4f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n =
                ffi::whiteout_m3_M3PhysicsShape_get_meshVertexPositions_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsShape_get_meshVertexPositions_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_mesh_vertex_positions(&mut self, values: &[crate::math::Vector4f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_assign_meshVertexPositions(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_mesh_vertex_positions(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_resize_meshVertexPositions(self.raw.as_ptr(), count)
        }
    }

    /// AABB center in model space (quantization grid origin)
    pub fn mesh_bounds_center(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_meshBoundsCenter(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_mesh_bounds_center(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_meshBoundsCenter(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// AABB half-extents (quantization range: tolerance = extent / 32767)
    pub fn mesh_bounds_extent(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_meshBoundsExtent(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_mesh_bounds_extent(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_meshBoundsExtent(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Per-axis quantization step (= extent / 32767)
    pub fn mesh_tolerance(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3PhysicsShape_get_meshTolerance(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_mesh_tolerance(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_meshTolerance(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Number of mesh normals
    pub fn mesh_normal_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshNormalCount(self.raw.as_ptr()) }
    }

    pub fn set_mesh_normal_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshNormalCount(self.raw.as_ptr(), value) }
    }

    /// Number of mesh vertices
    pub fn mesh_vertex_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshVertexCount(self.raw.as_ptr()) }
    }

    pub fn set_mesh_vertex_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshVertexCount(self.raw.as_ptr(), value) }
    }

    /// MT16 face count (0 when MT32)
    pub fn mesh_face_index_16_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshFaceIndex16Count(self.raw.as_ptr()) }
    }

    pub fn set_mesh_face_index_16_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_meshFaceIndex16Count(self.raw.as_ptr(), value)
        }
    }

    /// MT32 face count (0 when MT16)
    pub fn mesh_face_index_32_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshFaceIndex32Count(self.raw.as_ptr()) }
    }

    pub fn set_mesh_face_index_32_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe {
            ffi::whiteout_m3_M3PhysicsShape_set_meshFaceIndex32Count(self.raw.as_ptr(), value)
        }
    }

    /// Unknown mesh parameter
    pub fn mesh_unknown_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshUnknown1(self.raw.as_ptr()) }
    }

    pub fn set_mesh_unknown_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshUnknown1(self.raw.as_ptr(), value) }
    }

    /// Reserved (always 0)
    pub fn mesh_reserved(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshReserved(self.raw.as_ptr()) }
    }

    pub fn set_mesh_reserved(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshReserved(self.raw.as_ptr(), value) }
    }

    /// BVH tree height (root-to-leaf path length, 1–12)
    pub fn mesh_tree_depth(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshTreeDepth(self.raw.as_ptr()) }
    }

    pub fn set_mesh_tree_depth(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshTreeDepth(self.raw.as_ptr(), value) }
    }

    /// Collision margin (MT16: small float; MT32: 0.0)
    pub fn mesh_collision_margin(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_get_meshCollisionMargin(self.raw.as_ptr()) }
    }

    pub fn set_mesh_collision_margin(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsShape_set_meshCollisionMargin(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsShape {
    fn default() -> Self {
        Self::new()
    }
}

/// PHRB — Rigid body (v2–v4, 56–104 bytes)
///
/// Havok rigid body with density, friction, restitution, damping, gravity scale, and collision shape references.
pub struct RigidBody {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3RigidBody>,
}

impl Drop for RigidBody {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3RigidBody_delete(self.raw.as_ptr()) }
    }
}

impl RigidBody {
    /// # 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_M3RigidBody) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| RigidBody { 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 RigidBody {}

impl core::fmt::Debug for RigidBody {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RigidBody").finish_non_exhaustive()
    }
}

impl RigidBody {
    /// # 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_m3_M3RigidBody_new();
            Self::from_raw(raw).expect("native RigidBody allocation failed")
        }
    }

    /// Simulation mode (v3+)
    pub fn simulation_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_simulationType(self.raw.as_ptr()) }
    }

    pub fn set_simulation_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_simulationType(self.raw.as_ptr(), value) }
    }

    /// Parent bone index
    pub fn parent_bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_parentBoneIndex(self.raw.as_ptr()) }
    }

    pub fn set_parent_bone_index(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_parentBoneIndex(self.raw.as_ptr(), value) }
    }

    /// Engine-specific body type (v3+)
    pub fn physics_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_physicsType(self.raw.as_ptr()) }
    }

    pub fn set_physics_type(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_physicsType(self.raw.as_ptr(), value) }
    }

    /// Body density
    pub fn density(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_density(self.raw.as_ptr(), value) }
    }

    /// Surface friction
    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_friction(self.raw.as_ptr(), value) }
    }

    /// Elasticity / bounciness
    pub fn restitution(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_restitution(self.raw.as_ptr(), value) }
    }

    /// Linear velocity damping
    pub fn linear_damping(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_linearDamping(self.raw.as_ptr(), value) }
    }

    /// Angular velocity damping
    pub fn angular_damping(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_angularDamping(self.raw.as_ptr(), value) }
    }

    /// Gravity influence scale
    pub fn gravity_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_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_m3_M3RigidBody_set_gravityScale(self.raw.as_ptr(), value) }
    }

    /// Animated dynamic state (v4+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn dynamic_state(&self) -> crate::support::Ref<'_, AnimRefU32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3RigidBody_get_dynamicState(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn dynamic_state_mut(&mut self) -> crate::support::RefMut<'_, AnimRefU32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3RigidBody_get_dynamicState(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Dynamic blend-out duration (v4+)
    pub fn dynamic_blend_out(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_dynamicBlendOut(self.raw.as_ptr()) }
    }

    pub fn set_dynamic_blend_out(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_dynamicBlendOut(self.raw.as_ptr(), value) }
    }

    /// Collision shapes (PHSH)
    pub fn rigid_body_shape_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_rigidBodyShape_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn rigid_body_shape(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsShape>> {
        if index >= self.rigid_body_shape_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_m3_M3RigidBody_get_rigidBodyShape_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn rigid_body_shape_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PhysicsShape>> {
        if index >= self.rigid_body_shape_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_m3_M3RigidBody_get_rigidBodyShape_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn rigid_body_shape_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsShape>> {
        (0..self.rigid_body_shape_len())
            .map(move |i| self.rigid_body_shape(i).expect("index below len"))
    }

    pub fn resize_rigid_body_shape(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3RigidBody_resize_rigidBodyShape(self.raw.as_ptr(), count) }
    }

    /// Rigid body flags
    pub fn flags(&self) -> RigidBodyFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        RigidBodyFlag(unsafe { ffi::whiteout_m3_M3RigidBody_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: RigidBodyFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// Local force channel bitmask
    pub fn local_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_localForces(self.raw.as_ptr()) }
    }

    pub fn set_local_forces(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_localForces(self.raw.as_ptr(), value) }
    }

    /// World force channel bitmask
    pub fn world_forces(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_worldForces(self.raw.as_ptr()) }
    }

    pub fn set_world_forces(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_worldForces(self.raw.as_ptr(), value) }
    }

    /// Simulation priority
    pub fn priority(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_get_priority(self.raw.as_ptr()) }
    }

    pub fn set_priority(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3RigidBody_set_priority(self.raw.as_ptr(), value) }
    }
}

impl Default for RigidBody {
    fn default() -> Self {
        Self::new()
    }
}

/// PHYJ — Physics joint (v0, 180 bytes)
///
/// Connects two rigid bodies with limit, friction, and break-threshold parameters.
pub struct PhysicsJoint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsJoint>,
}

impl Drop for PhysicsJoint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_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_M3PhysicsJoint) -> 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_m3_M3PhysicsJoint_new();
            Self::from_raw(raw).expect("native PhysicsJoint allocation failed")
        }
    }

    /// Joint type
    pub fn joint_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_jointType(self.raw.as_ptr()) }
    }

    pub fn set_joint_type(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_jointType(self.raw.as_ptr(), value) }
    }

    /// First bone index
    pub fn bone_index_1(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_boneIndex1(self.raw.as_ptr()) }
    }

    pub fn set_bone_index_1(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_boneIndex1(self.raw.as_ptr(), value) }
    }

    /// Second bone index
    pub fn bone_index_2(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_boneIndex2(self.raw.as_ptr()) }
    }

    pub fn set_bone_index_2(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_boneIndex2(self.raw.as_ptr(), value) }
    }

    /// Enable angular limits
    pub fn enable_limits(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_enableLimits(self.raw.as_ptr()) }
    }

    pub fn set_enable_limits(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_enableLimits(self.raw.as_ptr(), value) }
    }

    /// Minimum limit angle
    pub fn limit_min(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_limitMin(self.raw.as_ptr()) }
    }

    pub fn set_limit_min(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_limitMin(self.raw.as_ptr(), value) }
    }

    /// Maximum limit angle
    pub fn limit_max(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_limitMax(self.raw.as_ptr()) }
    }

    pub fn set_limit_max(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_limitMax(self.raw.as_ptr(), value) }
    }

    /// Cone constraint angle
    pub fn cone_angle(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_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_m3_M3PhysicsJoint_set_coneAngle(self.raw.as_ptr(), value) }
    }

    /// Enable joint friction
    pub fn enable_friction(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_enableFriction(self.raw.as_ptr()) }
    }

    pub fn set_enable_friction(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_enableFriction(self.raw.as_ptr(), value) }
    }

    /// Friction coefficient
    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_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_m3_M3PhysicsJoint_set_friction(self.raw.as_ptr(), value) }
    }

    /// Damping ratio
    pub fn damping_ratio(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_dampingRatio(self.raw.as_ptr()) }
    }

    pub fn set_damping_ratio(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_dampingRatio(self.raw.as_ptr(), value) }
    }

    /// Angular frequency
    pub fn angular_frequency(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_angularFrequency(self.raw.as_ptr()) }
    }

    pub fn set_angular_frequency(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_angularFrequency(self.raw.as_ptr(), value) }
    }

    /// Force threshold to break joint
    pub fn break_threshold(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_breakThreshold(self.raw.as_ptr()) }
    }

    pub fn set_break_threshold(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_breakThreshold(self.raw.as_ptr(), value) }
    }

    /// Enable shape constraint
    pub fn enable_shape(&self) -> u8 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_get_enableShape(self.raw.as_ptr()) }
    }

    pub fn set_enable_shape(&mut self, value: u8) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsJoint_set_enableShape(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsJoint {
    fn default() -> Self {
        Self::new()
    }
}

/// PHCT — Physics constraint (v0, 24 bytes)
///
/// Constrains two rigid bodies with break-force threshold.
pub struct PhysicsConstraint {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3PhysicsConstraint>,
}

impl Drop for PhysicsConstraint {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_delete(self.raw.as_ptr()) }
    }
}

impl PhysicsConstraint {
    /// # 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_M3PhysicsConstraint) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| PhysicsConstraint { 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 PhysicsConstraint {}

impl core::fmt::Debug for PhysicsConstraint {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PhysicsConstraint").finish_non_exhaustive()
    }
}

impl PhysicsConstraint {
    /// # 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_m3_M3PhysicsConstraint_new();
            Self::from_raw(raw).expect("native PhysicsConstraint allocation failed")
        }
    }

    /// Dependent bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn dependents(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3PhysicsConstraint_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsConstraint_get_dependents_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 dependents_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3PhysicsConstraint_get_dependents_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3PhysicsConstraint_get_dependents_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_dependents(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3PhysicsConstraint_assign_dependents(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_dependents(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_resize_dependents(self.raw.as_ptr(), count) }
    }

    /// First rigid body index
    pub fn rigid_body_1(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_get_rigidBody1(self.raw.as_ptr()) }
    }

    pub fn set_rigid_body_1(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_set_rigidBody1(self.raw.as_ptr(), value) }
    }

    /// Second rigid body index
    pub fn rigid_body_2(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_get_rigidBody2(self.raw.as_ptr()) }
    }

    pub fn set_rigid_body_2(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_set_rigidBody2(self.raw.as_ptr(), value) }
    }

    /// Force required to break constraint
    pub fn break_force(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_get_breakForce(self.raw.as_ptr()) }
    }

    pub fn set_break_force(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3PhysicsConstraint_set_breakForce(self.raw.as_ptr(), value) }
    }
}

impl Default for PhysicsConstraint {
    fn default() -> Self {
        Self::new()
    }
}

/// PHCC — Cloth collider (v0, 76 bytes)
///
/// Capsule-shaped collider used by cloth simulation.
pub struct ClothCollider {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ClothCollider>,
}

impl Drop for ClothCollider {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ClothCollider_delete(self.raw.as_ptr()) }
    }
}

impl ClothCollider {
    /// # 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_M3ClothCollider) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ClothCollider { 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 ClothCollider {}

impl core::fmt::Debug for ClothCollider {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ClothCollider").finish_non_exhaustive()
    }
}

impl ClothCollider {
    /// # 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_m3_M3ClothCollider_new();
            Self::from_raw(raw).expect("native ClothCollider allocation failed")
        }
    }

    /// Capsule radius
    pub fn radius(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothCollider_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_m3_M3ClothCollider_set_radius(self.raw.as_ptr(), value) }
    }

    /// Capsule height
    pub fn height(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothCollider_get_height(self.raw.as_ptr()) }
    }

    pub fn set_height(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothCollider_set_height(self.raw.as_ptr(), value) }
    }

    /// Alignment padding
    pub fn padding(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothCollider_get_padding(self.raw.as_ptr()) }
    }

    pub fn set_padding(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothCollider_set_padding(self.raw.as_ptr(), value) }
    }
}

impl Default for ClothCollider {
    fn default() -> Self {
        Self::new()
    }
}

/// PHAC — Cloth proxy (v0, 32 bytes)
///
/// Maps cloth vertices to proxy geometry for collision.
pub struct ClothProxy {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ClothProxy>,
}

impl Drop for ClothProxy {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ClothProxy_delete(self.raw.as_ptr()) }
    }
}

impl ClothProxy {
    /// # 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_M3ClothProxy) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ClothProxy { 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 ClothProxy {}

impl core::fmt::Debug for ClothProxy {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ClothProxy").finish_non_exhaustive()
    }
}

impl ClothProxy {
    /// # 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_m3_M3ClothProxy_new();
            Self::from_raw(raw).expect("native ClothProxy allocation failed")
        }
    }

    /// Proxy mesh index
    pub fn proxy_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothProxy_get_proxyIndex(self.raw.as_ptr()) }
    }

    pub fn set_proxy_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothProxy_set_proxyIndex(self.raw.as_ptr(), value) }
    }

    /// Cloth mesh index
    pub fn cloth_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothProxy_get_clothIndex(self.raw.as_ptr()) }
    }

    pub fn set_cloth_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothProxy_set_clothIndex(self.raw.as_ptr(), value) }
    }

    /// Proxy vertex data (U64_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn proxy_vertices(&self) -> &[u64] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothProxy_get_proxyVertices_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothProxy_get_proxyVertices_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 proxy_vertices_mut(&mut self) -> &mut [u64] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothProxy_get_proxyVertices_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3ClothProxy_get_proxyVertices_data(self.raw.as_ptr()) as *mut u64;
            if p.is_null() || n == 0 {
                &mut []
            } else {
                core::slice::from_raw_parts_mut(p, n)
            }
        }
    }

    pub fn set_proxy_vertices(&mut self, values: &[u64]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothProxy_assign_proxyVertices(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_proxy_vertices(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothProxy_resize_proxyVertices(self.raw.as_ptr(), count) }
    }

    /// Proxy blend weights (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn proxy_weights(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothProxy_get_proxyWeights_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothProxy_get_proxyWeights_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 proxy_weights_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothProxy_get_proxyWeights_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3ClothProxy_get_proxyWeights_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_proxy_weights(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothProxy_assign_proxyWeights(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_proxy_weights(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothProxy_resize_proxyWeights(self.raw.as_ptr(), count) }
    }
}

impl Default for ClothProxy {
    fn default() -> Self {
        Self::new()
    }
}

/// PHCL — Cloth physics (v0–v4, 192 bytes)
///
/// Full cloth simulation configuration: skin bone binding, stiffness parameters, damping, wind/explosion/gravity scales, colliders, and proxies. Added in MODL v28.
pub struct ClothPhysics {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3ClothPhysics>,
}

impl Drop for ClothPhysics {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_delete(self.raw.as_ptr()) }
    }
}

impl ClothPhysics {
    /// # 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_M3ClothPhysics) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| ClothPhysics { 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 ClothPhysics {}

impl core::fmt::Debug for ClothPhysics {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ClothPhysics").finish_non_exhaustive()
    }
}

impl ClothPhysics {
    /// # 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_m3_M3ClothPhysics_new();
            Self::from_raw(raw).expect("native ClothPhysics allocation failed")
        }
    }

    /// Number of cloth mesh sections
    pub fn cloth_mesh_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_clothMeshCount(self.raw.as_ptr()) }
    }

    pub fn set_cloth_mesh_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_clothMeshCount(self.raw.as_ptr(), value) }
    }

    /// Number of skin bones
    pub fn skin_bone_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_skinBoneCount(self.raw.as_ptr()) }
    }

    pub fn set_skin_bone_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_skinBoneCount(self.raw.as_ptr(), value) }
    }

    /// Skin bone indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn skin_bones(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_skinBones_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothPhysics_get_skinBones_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 skin_bones_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_skinBones_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3ClothPhysics_get_skinBones_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_skin_bones(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothPhysics_assign_skinBones(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_skin_bones(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_skinBones(self.raw.as_ptr(), count) }
    }

    /// Per-vertex simulation enable flags (U8__)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn sim_enabled(&self) -> &[u8] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_simEnabled_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothPhysics_get_simEnabled_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 sim_enabled_mut(&mut self) -> &mut [u8] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_simEnabled_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3ClothPhysics_get_simEnabled_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_sim_enabled(&mut self, values: &[u8]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothPhysics_assign_simEnabled(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_sim_enabled(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_simEnabled(self.raw.as_ptr(), count) }
    }

    /// Per-vertex bone indices (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn vertex_bones(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_vertexBones_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothPhysics_get_vertexBones_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 vertex_bones_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_vertexBones_count(self.raw.as_ptr());
            let p =
                ffi::whiteout_m3_M3ClothPhysics_get_vertexBones_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_vertex_bones(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothPhysics_assign_vertexBones(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vertex_bones(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_vertexBones(self.raw.as_ptr(), count) }
    }

    /// Per-vertex bone weights (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn vertex_weights(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_vertexWeights_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothPhysics_get_vertexWeights_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 vertex_weights_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3ClothPhysics_get_vertexWeights_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3ClothPhysics_get_vertexWeights_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_vertex_weights(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3ClothPhysics_assign_vertexWeights(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_vertex_weights(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_vertexWeights(self.raw.as_ptr(), count) }
    }

    /// Cloth colliders (PHCC)
    pub fn colliders_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_colliders_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn colliders(&self, index: usize) -> Option<crate::support::Ref<'_, ClothCollider>> {
        if index >= self.colliders_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ClothCollider {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3ClothPhysics_get_colliders_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn colliders_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ClothCollider>> {
        if index >= self.colliders_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ClothCollider {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3ClothPhysics_get_colliders_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn colliders_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ClothCollider>> {
        (0..self.colliders_len()).map(move |i| self.colliders(i).expect("index below len"))
    }

    pub fn resize_colliders(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_colliders(self.raw.as_ptr(), count) }
    }

    /// Cloth proxies (PHAC)
    pub fn proxies_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_proxies_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn proxies(&self, index: usize) -> Option<crate::support::Ref<'_, ClothProxy>> {
        if index >= self.proxies_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ClothProxy {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3ClothPhysics_get_proxies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn proxies_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, ClothProxy>> {
        if index >= self.proxies_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ClothProxy {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3ClothPhysics_get_proxies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn proxies_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ClothProxy>> {
        (0..self.proxies_len()).map(move |i| self.proxies(i).expect("index below len"))
    }

    pub fn resize_proxies(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_resize_proxies(self.raw.as_ptr(), count) }
    }

    /// Cloth density
    pub fn density(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_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_m3_M3ClothPhysics_set_density(self.raw.as_ptr(), value) }
    }

    /// Tracking factor
    pub fn tracking(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_tracking(self.raw.as_ptr()) }
    }

    pub fn set_tracking(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_tracking(self.raw.as_ptr(), value) }
    }

    /// Stretch stiffness
    pub fn stretch_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_stretchStiffness(self.raw.as_ptr()) }
    }

    pub fn set_stretch_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_stretchStiffness(self.raw.as_ptr(), value) }
    }

    /// Horizontal stiffness
    pub fn horizontal_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_horizontalStiffness(self.raw.as_ptr()) }
    }

    pub fn set_horizontal_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_horizontalStiffness(self.raw.as_ptr(), value) }
    }

    /// Bending stiffness
    pub fn bending_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_bendingStiffness(self.raw.as_ptr()) }
    }

    pub fn set_bending_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_bendingStiffness(self.raw.as_ptr(), value) }
    }

    /// Damping coefficient
    pub fn damping(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_damping(self.raw.as_ptr()) }
    }

    pub fn set_damping(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_damping(self.raw.as_ptr(), value) }
    }

    /// Friction coefficient
    pub fn friction(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_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_m3_M3ClothPhysics_set_friction(self.raw.as_ptr(), value) }
    }

    /// Gravity influence
    pub fn gravity(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_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_m3_M3ClothPhysics_set_gravity(self.raw.as_ptr(), value) }
    }

    /// Explosion force scale
    pub fn explosion_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_explosionScale(self.raw.as_ptr()) }
    }

    pub fn set_explosion_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_explosionScale(self.raw.as_ptr(), value) }
    }

    /// Wind force scale
    pub fn wind_scale(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_windScale(self.raw.as_ptr()) }
    }

    pub fn set_wind_scale(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_windScale(self.raw.as_ptr(), value) }
    }

    /// Shear stiffness
    pub fn shear_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_shearStiffness(self.raw.as_ptr()) }
    }

    pub fn set_shear_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_shearStiffness(self.raw.as_ptr(), value) }
    }

    /// Drag factor
    pub fn drag_factor(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_dragFactor(self.raw.as_ptr()) }
    }

    pub fn set_drag_factor(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_dragFactor(self.raw.as_ptr(), value) }
    }

    /// Lift factor (v4+)
    pub fn lift_factor(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_liftFactor(self.raw.as_ptr()) }
    }

    pub fn set_lift_factor(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_liftFactor(self.raw.as_ptr(), value) }
    }

    /// Sphere collider stiffness (v4+)
    pub fn sphere_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_sphereStiffness(self.raw.as_ptr()) }
    }

    pub fn set_sphere_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_sphereStiffness(self.raw.as_ptr(), value) }
    }

    /// Flatten mode (v4+)
    pub fn flatten(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_flatten(self.raw.as_ptr()) }
    }

    pub fn set_flatten(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_flatten(self.raw.as_ptr(), value) }
    }

    /// Animated active state
    /// Borrows the field in place — no copy, no allocation.
    pub fn active(&self) -> crate::support::Ref<'_, AnimRefU32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3ClothPhysics_get_active(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn active_mut(&mut self) -> crate::support::RefMut<'_, AnimRefU32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefU32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3ClothPhysics_get_active(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Use skin mesh for collision
    pub fn use_skin_collision(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_useSkinCollision(self.raw.as_ptr()) }
    }

    pub fn set_use_skin_collision(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_useSkinCollision(self.raw.as_ptr(), value) }
    }

    /// Skin collision offset
    pub fn skin_offset(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_skinOffset(self.raw.as_ptr()) }
    }

    pub fn set_skin_offset(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_skinOffset(self.raw.as_ptr(), value) }
    }

    /// Skin collision exponent
    pub fn skin_exponent(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_skinExponent(self.raw.as_ptr()) }
    }

    pub fn set_skin_exponent(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_skinExponent(self.raw.as_ptr(), value) }
    }

    /// Skin collision stiffness
    pub fn skin_stiffness(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_skinStiffness(self.raw.as_ptr()) }
    }

    pub fn set_skin_stiffness(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_skinStiffness(self.raw.as_ptr(), value) }
    }

    /// Local force channel bitmask
    pub fn local_channels(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_get_localChannels(self.raw.as_ptr()) }
    }

    pub fn set_local_channels(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3ClothPhysics_set_localChannels(self.raw.as_ptr(), value) }
    }

    /// Local wind direction and magnitude
    pub fn local_wind(&self) -> crate::math::Vector3f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3ClothPhysics_get_localWind(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_local_wind(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3ClothPhysics_set_localWind(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }
}

impl Default for ClothPhysics {
    fn default() -> Self {
        Self::new()
    }
}

/// LITE — Light source (v0–v7, 212 bytes)
///
/// Omni, spot, or directional light with animated diffuse/specular colors, intensity, decay, attenuation start/end, and spot-light hot-spot/falloff.
pub struct Light {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Light>,
}

impl Drop for Light {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Light_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_M3Light) -> 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_m3_M3Light_new();
            Self::from_raw(raw).expect("native Light allocation failed")
        }
    }

    /// Light type (omni/spot/directional)
    pub fn light_type(&self) -> LightType {
        // SAFETY: scalar read; the discriminant is validated below.
        unsafe { ffi::whiteout_m3_M3Light_get_lightType(self.raw.as_ptr()) }
            .try_into()
            .expect("unknown enum discriminant from the native library")
    }

    pub fn set_light_type(&mut self, value: LightType) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_set_lightType(self.raw.as_ptr(), value as i32) }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_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_m3_M3Light_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Light flags (shadows, specular, AO, etc.)
    pub fn flags(&self) -> LightFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        LightFlag(unsafe { ffi::whiteout_m3_M3Light_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: LightFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// LOD cut-off level
    pub fn lod_cut(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_get_lodCut(self.raw.as_ptr()) }
    }

    pub fn set_lod_cut(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_set_lodCut(self.raw.as_ptr(), value) }
    }

    /// Shadow LOD cut-off level
    pub fn shadow_lod_cut(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_get_shadowLodCut(self.raw.as_ptr()) }
    }

    pub fn set_shadow_lod_cut(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_set_shadowLodCut(self.raw.as_ptr(), value) }
    }

    /// Animated diffuse color (RGB)
    /// Borrows the field in place — no copy, no allocation.
    pub fn diffuse_color(&self) -> crate::support::Ref<'_, AnimRefVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_diffuseColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn diffuse_color_mut(&mut self) -> crate::support::RefMut<'_, AnimRefVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_diffuseColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated intensity multiplier
    /// Borrows the field in place — no copy, no allocation.
    pub fn intensity_multiplier(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_intensityMultiplier(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn intensity_multiplier_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_intensityMultiplier(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated specular color (RGB)
    /// Borrows the field in place — no copy, no allocation.
    pub fn specular_color(&self) -> crate::support::Ref<'_, AnimRefVector3f> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_specularColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn specular_color_mut(&mut self) -> crate::support::RefMut<'_, AnimRefVector3f> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefVector3f {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_specularColor(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated specular multiplier
    /// Borrows the field in place — no copy, no allocation.
    pub fn specular_multiplier(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_specularMultiplier(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn specular_multiplier_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_specularMultiplier(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated distance decay exponent
    /// Borrows the field in place — no copy, no allocation.
    pub fn decay(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_decay(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn decay_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_decay(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Attenuation end distance
    pub fn attenuation_end(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_get_attenuationEnd(self.raw.as_ptr()) }
    }

    pub fn set_attenuation_end(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Light_set_attenuationEnd(self.raw.as_ptr(), value) }
    }

    /// Animated attenuation start distance
    /// Borrows the field in place — no copy, no allocation.
    pub fn attenuation_start(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_attenuationStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn attenuation_start_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Light_get_attenuationStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated spot inner cone angle
    /// Borrows the field in place — no copy, no allocation.
    pub fn hot_spot(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_hotSpot(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn hot_spot_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_hotSpot(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated spot outer cone falloff
    /// Borrows the field in place — no copy, no allocation.
    pub fn falloff(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_falloff(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn falloff_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Light_get_falloff(
                    self.raw.as_ptr(),
                )),
            })
        }
    }
}

impl Default for Light {
    fn default() -> Self {
        Self::new()
    }
}

/// CAM_ — Camera (v2–v5, 144–264 bytes)
///
/// Bone-attached camera with animated FOV, clip planes, shadow clip distance, depth-of-field parameters, and version-dependent bokeh settings.
pub struct Camera {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Camera>,
}

impl Drop for Camera {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Camera_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_M3Camera) -> 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_m3_M3Camera_new();
            Self::from_raw(raw).expect("native Camera allocation failed")
        }
    }

    /// Index into BONE array
    pub fn bone_index(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_get_boneIndex(self.raw.as_ptr()) }
    }

    pub fn set_bone_index(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_set_boneIndex(self.raw.as_ptr(), value) }
    }

    /// Camera name (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe {
            crate::support::take_string(ffi::whiteout_m3_M3Camera_get_name(self.raw.as_ptr()))
        }
    }

    pub fn set_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m3_M3Camera_set_name(self.raw.as_ptr(), value.as_ptr()) }
    }

    /// Animated FOV in radians (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn field_of_view(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_fieldOfView(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn field_of_view_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_fieldOfView(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Use vertical FOV (0 or 1, v2+)
    pub fn use_vertical_fov(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_get_useVerticalFOV(self.raw.as_ptr()) }
    }

    pub fn set_use_vertical_fov(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_set_useVerticalFOV(self.raw.as_ptr(), value) }
    }

    /// DOF type (v5 only, default 3)
    pub fn dof_type(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_get_dofType(self.raw.as_ptr()) }
    }

    pub fn set_dof_type(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Camera_set_dofType(self.raw.as_ptr(), value) }
    }

    /// Animated far clip plane (v3+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn far_clip(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_farClip(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn far_clip_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_farClip(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated near clip plane (v3+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn near_clip(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_nearClip(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn near_clip_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_nearClip(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated shadow clip distance (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn shadow_clip_distance(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_shadowClipDistance(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn shadow_clip_distance_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_shadowClipDistance(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated DOF focal point distance (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn focus_distance(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_focusDistance(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn focus_distance_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_focusDistance(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated DOF far focus range (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn far_focus_range(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_farFocusRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn far_focus_range_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_farFocusRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated DOF near focus range (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn near_focus_range(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFocusRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn near_focus_range_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFocusRange(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated near falloff start (v4+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn near_falloff_start(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFalloffStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn near_falloff_start_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFalloffStart(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated near falloff end (v4+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn near_falloff_end(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFalloffEnd(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn near_falloff_end_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_nearFalloffEnd(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Animated DOF strength (v2+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn dof_amount(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_dofAmount(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn dof_amount_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_dofAmount(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated bokeh f-stop (v5+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn bokeh_f_stop(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_bokehFStop(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bokeh_f_stop_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Camera_get_bokehFStop(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Animated bokeh max CoC diameter (v5+)
    /// Borrows the field in place — no copy, no allocation.
    pub fn bokeh_max_co_c_diameter(&self) -> crate::support::Ref<'_, AnimRefF32> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_bokehMaxCoCDiameter(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn bokeh_max_co_c_diameter_mut(&mut self) -> crate::support::RefMut<'_, AnimRefF32> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(AnimRefF32 {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Camera_get_bokehMaxCoCDiameter(self.raw.as_ptr()),
                ),
            })
        }
    }
}

impl Default for Camera {
    fn default() -> Self {
        Self::new()
    }
}

/// MODL — Model root chunk (v23–v30, 784–868 bytes)
///
/// The root of all model data. Contains `Ref<T>` fields pointing to every sub-chunk in the file: skeleton, mesh, materials, particles, physics, etc. The preamble (bytes 0x000–0x0E3) is identical across all versions; version-dependent material and physics references follow at 0x0E4+.
///
/// Version history: - v23 (784 bytes): Base release layout - v24 (+ikCCD): 796 bytes - v25 (+volumeNoiseMaterials): 808 bytes - v26 (+stbMaterials): 820 bytes - v28 (+reflectionMaterials, +clothPhysics): 844 bytes - v29 (+lensFlareMaterials): 856 bytes - v30 (+dataDrivenMaterials): 868 bytes
pub struct Model {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Model>,
}

impl Drop for Model {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Model_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_M3Model) -> 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_m3_M3Model_new();
            Self::from_raw(raw).expect("native Model allocation failed")
        }
    }

    /// Model file path (`Ref<CHAR>`)
    pub fn name(&self) -> String {
        // SAFETY: the native side hands over an owned CString.
        unsafe { crate::support::take_string(ffi::whiteout_m3_M3Model_get_name(self.raw.as_ptr())) }
    }

    pub fn set_name(&mut self, value: &str) {
        let value = std::ffi::CString::new(value).unwrap_or_default();
        // SAFETY: the pointer outlives the call.
        unsafe { ffi::whiteout_m3_M3Model_set_name(self.raw.as_ptr(), value.as_ptr()) }
    }

    /// Not `None`: only 21 of the corpus's 56,146 models leave this at zero. These three are latches saying "this work is already done, do not redo it", and the converter does all three -- it sorts every `STC_`'s animIds, states `kAnimRefBound` on every bound AnimRef, and derives every `BONE.flags` from those (`m3_anim::SolveBoneAnimFlags`). The rest of the shipped bits are left clear so the editor recomputes them. A parsed or restored model overwrites this wholesale.
    pub fn flags(&self) -> ModelFlag {
        // SAFETY: scalar read; a flag set accepts any bits.
        ModelFlag(unsafe { ffi::whiteout_m3_M3Model_get_flags(self.raw.as_ptr()) })
    }

    pub fn set_flags(&mut self, value: ModelFlag) {
        // SAFETY: scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_set_flags(self.raw.as_ptr(), value.0) }
    }

    /// Animation sequences (SEQS)
    pub fn sequences_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_sequences(self.raw.as_ptr(), count) }
    }

    /// Sub-track containers (STC_) with keyframe refs
    pub fn sub_track_collections_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_subTrackCollections_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn sub_track_collections(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, SubTrackContainer>> {
        if index >= self.sub_track_collections_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(SubTrackContainer {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_subTrackCollections_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn sub_track_collections_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, SubTrackContainer>> {
        if index >= self.sub_track_collections_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(SubTrackContainer {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_subTrackCollections_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn sub_track_collections_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, SubTrackContainer>> {
        (0..self.sub_track_collections_len())
            .map(move |i| self.sub_track_collections(i).expect("index below len"))
    }

    pub fn resize_sub_track_collections(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_subTrackCollections(self.raw.as_ptr(), count) }
    }

    /// Animation groups (STG_)
    pub fn animation_groups_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_animationGroups_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn animation_groups(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, AnimationGroup>> {
        if index >= self.animation_groups_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(AnimationGroup {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_animationGroups_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn animation_groups_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, AnimationGroup>> {
        if index >= self.animation_groups_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(AnimationGroup {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_animationGroups_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn animation_groups_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, AnimationGroup>> {
        (0..self.animation_groups_len())
            .map(move |i| self.animation_groups(i).expect("index below len"))
    }

    pub fn resize_animation_groups(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_animationGroups(self.raw.as_ptr(), count) }
    }

    /// Bone animation sets (BSET, always null)
    pub fn bone_animation_sets_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_boneAnimationSets_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn bone_animation_sets(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, BoneAnimationSet>> {
        if index >= self.bone_animation_sets_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(BoneAnimationSet {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_boneAnimationSets_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn bone_animation_sets_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, BoneAnimationSet>> {
        if index >= self.bone_animation_sets_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(BoneAnimationSet {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_boneAnimationSets_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn bone_animation_sets_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, BoneAnimationSet>> {
        (0..self.bone_animation_sets_len())
            .map(move |i| self.bone_animation_sets(i).expect("index below len"))
    }

    pub fn resize_bone_animation_sets(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_boneAnimationSets(self.raw.as_ptr(), count) }
    }

    /// Always 0
    pub fn animation_split_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_animationSplitCount(self.raw.as_ptr()) }
    }

    pub fn set_animation_split_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_set_animationSplitCount(self.raw.as_ptr(), value) }
    }

    /// Animation states (STS_)
    pub fn animation_states_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_animationStates_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn animation_states(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, AnimationState>> {
        if index >= self.animation_states_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(AnimationState {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_animationStates_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn animation_states_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, AnimationState>> {
        if index >= self.animation_states_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(AnimationState {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_animationStates_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn animation_states_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, AnimationState>> {
        (0..self.animation_states_len())
            .map(move |i| self.animation_states(i).expect("index below len"))
    }

    pub fn resize_animation_states(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_animationStates(self.raw.as_ptr(), count) }
    }

    /// Skeleton bones (BONE)
    pub fn bones_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_bones(self.raw.as_ptr(), count) }
    }

    /// Number of bones affecting skin
    pub fn skin_bone_count(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_skinBoneCount(self.raw.as_ptr()) }
    }

    pub fn set_skin_bone_count(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_set_skinBoneCount(self.raw.as_ptr(), value) }
    }

    /// Mesh divisions (DIV_: faces, regions, batches)
    pub fn divisions_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_divisions_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn divisions(&self, index: usize) -> Option<crate::support::Ref<'_, MeshDivision>> {
        if index >= self.divisions_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(MeshDivision {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_divisions_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn divisions_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, MeshDivision>> {
        if index >= self.divisions_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(MeshDivision {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_divisions_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn divisions_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, MeshDivision>> {
        (0..self.divisions_len()).map(move |i| self.divisions(i).expect("index below len"))
    }

    pub fn resize_divisions(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_divisions(self.raw.as_ptr(), count) }
    }

    /// Bone index remap table (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn bone_lookup(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_boneLookup_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_boneLookup_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_lookup_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_boneLookup_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_boneLookup_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_lookup(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_boneLookup(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_bone_lookup(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_boneLookup(self.raw.as_ptr(), count) }
    }

    /// Model bounding volume
    /// Borrows the field in place — no copy, no allocation.
    pub fn bounds(&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_m3_M3Model_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    pub fn bounds_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_m3_M3Model_get_bounds(
                    self.raw.as_ptr(),
                )),
            })
        }
    }

    /// Collision bounding volume
    /// Borrows the field in place — no copy, no allocation.
    pub fn collision_bounds(&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_m3_M3Model_get_collisionBounds(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn collision_bounds_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_m3_M3Model_get_collisionBounds(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Collision triangle indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_faces(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_collisionFaces_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionFaces_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_faces_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_collisionFaces_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionFaces_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_faces(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_collisionFaces(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_faces(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_collisionFaces(self.raw.as_ptr(), count) }
    }

    /// Collision vertex positions (VEC3)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_verts(&self) -> &[crate::math::Vector3f] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_collisionVerts_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionVerts_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_verts_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_collisionVerts_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionVerts_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_verts(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_collisionVerts(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_verts(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_collisionVerts(self.raw.as_ptr(), count) }
    }

    /// Collision face normals (VEC3)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn collision_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_m3_M3Model_get_collisionNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionNormals_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_normals_mut(&mut self) -> &mut [crate::math::Vector3f] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_collisionNormals_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_collisionNormals_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_normals(&mut self, values: &[crate::math::Vector3f]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_collisionNormals(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_collision_normals(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_collisionNormals(self.raw.as_ptr(), count) }
    }

    /// Named bone locations (ATT_)
    pub fn attachment_points_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_attachmentPoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn attachment_points(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, AttachmentPoint>> {
        if index >= self.attachment_points_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(AttachmentPoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_attachmentPoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn attachment_points_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, AttachmentPoint>> {
        if index >= self.attachment_points_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(AttachmentPoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_attachmentPoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn attachment_points_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, AttachmentPoint>> {
        (0..self.attachment_points_len())
            .map(move |i| self.attachment_points(i).expect("index below len"))
    }

    pub fn resize_attachment_points(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_attachmentPoints(self.raw.as_ptr(), count) }
    }

    /// Attachment point addon indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn attachment_point_addons(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentPointAddons_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentPointAddons_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_point_addons_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentPointAddons_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentPointAddons_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_point_addons(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_attachmentPointAddons(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_attachment_point_addons(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_attachmentPointAddons(self.raw.as_ptr(), count) }
    }

    /// Lights (LITE)
    pub fn lights_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_lights(self.raw.as_ptr(), count) }
    }

    /// Shadow boxes (SHBX)
    pub fn shadow_boxes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_shadowBoxes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn shadow_boxes(&self, index: usize) -> Option<crate::support::Ref<'_, ShadowBox>> {
        if index >= self.shadow_boxes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ShadowBox {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_shadowBoxes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn shadow_boxes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ShadowBox>> {
        if index >= self.shadow_boxes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ShadowBox {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_shadowBoxes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn shadow_boxes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ShadowBox>> {
        (0..self.shadow_boxes_len()).map(move |i| self.shadow_boxes(i).expect("index below len"))
    }

    pub fn resize_shadow_boxes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_shadowBoxes(self.raw.as_ptr(), count) }
    }

    /// Cameras (CAM_)
    pub fn cameras_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_cameras(self.raw.as_ptr(), count) }
    }

    /// Camera addon indices (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn cameras_addons(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_camerasAddons_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_camerasAddons_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 cameras_addons_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_camerasAddons_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_camerasAddons_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_cameras_addons(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_camerasAddons(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_cameras_addons(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_camerasAddons(self.raw.as_ptr(), count) }
    }

    /// Material type+index maps (MATM)
    pub fn material_maps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_materialMaps_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn material_maps(&self, index: usize) -> Option<crate::support::Ref<'_, MaterialMap>> {
        if index >= self.material_maps_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(MaterialMap {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_materialMaps_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn material_maps_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, MaterialMap>> {
        if index >= self.material_maps_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(MaterialMap {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_materialMaps_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn material_maps_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, MaterialMap>> {
        (0..self.material_maps_len()).map(move |i| self.material_maps(i).expect("index below len"))
    }

    pub fn resize_material_maps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_materialMaps(self.raw.as_ptr(), count) }
    }

    /// Standard materials (MAT_)
    pub fn standard_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_standardMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn standard_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, StandardMaterial>> {
        if index >= self.standard_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(StandardMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_standardMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn standard_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, StandardMaterial>> {
        if index >= self.standard_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(StandardMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_standardMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn standard_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, StandardMaterial>> {
        (0..self.standard_materials_len())
            .map(move |i| self.standard_materials(i).expect("index below len"))
    }

    pub fn resize_standard_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_standardMaterials(self.raw.as_ptr(), count) }
    }

    /// Displacement materials (DIS_)
    pub fn displacement_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_displacementMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn displacement_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, DisplacementMaterial>> {
        if index >= self.displacement_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DisplacementMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_displacementMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn displacement_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DisplacementMaterial>> {
        if index >= self.displacement_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DisplacementMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_displacementMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn displacement_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DisplacementMaterial>> {
        (0..self.displacement_materials_len())
            .map(move |i| self.displacement_materials(i).expect("index below len"))
    }

    pub fn resize_displacement_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_displacementMaterials(self.raw.as_ptr(), count) }
    }

    /// Composite materials (CMP_)
    pub fn composite_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_compositeMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn composite_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, CompositeMaterial>> {
        if index >= self.composite_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(CompositeMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_compositeMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn composite_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, CompositeMaterial>> {
        if index >= self.composite_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(CompositeMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_compositeMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn composite_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, CompositeMaterial>> {
        (0..self.composite_materials_len())
            .map(move |i| self.composite_materials(i).expect("index below len"))
    }

    pub fn resize_composite_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_compositeMaterials(self.raw.as_ptr(), count) }
    }

    /// Terrain materials (TER_)
    pub fn terrain_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_terrainMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn terrain_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, TerrainMaterial>> {
        if index >= self.terrain_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TerrainMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_terrainMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn terrain_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TerrainMaterial>> {
        if index >= self.terrain_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TerrainMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_terrainMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn terrain_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TerrainMaterial>> {
        (0..self.terrain_materials_len())
            .map(move |i| self.terrain_materials(i).expect("index below len"))
    }

    pub fn resize_terrain_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_terrainMaterials(self.raw.as_ptr(), count) }
    }

    /// Volume materials (VOL_)
    pub fn volume_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_volumeMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn volume_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, VolumeMaterial>> {
        if index >= self.volume_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(VolumeMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_volumeMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn volume_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, VolumeMaterial>> {
        if index >= self.volume_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(VolumeMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_volumeMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn volume_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, VolumeMaterial>> {
        (0..self.volume_materials_len())
            .map(move |i| self.volume_materials(i).expect("index below len"))
    }

    pub fn resize_volume_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_volumeMaterials(self.raw.as_ptr(), count) }
    }

    /// Hair materials (HAI_, defunct — always null)
    pub fn hair_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_hairMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn hair_materials(&self, index: usize) -> Option<crate::support::Ref<'_, HairMaterial>> {
        if index >= self.hair_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(HairMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_hairMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn hair_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, HairMaterial>> {
        if index >= self.hair_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(HairMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_hairMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn hair_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, HairMaterial>> {
        (0..self.hair_materials_len())
            .map(move |i| self.hair_materials(i).expect("index below len"))
    }

    pub fn resize_hair_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_hairMaterials(self.raw.as_ptr(), count) }
    }

    /// Creep materials (CREP)
    pub fn creep_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_creepMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn creep_materials(&self, index: usize) -> Option<crate::support::Ref<'_, CreepMaterial>> {
        if index >= self.creep_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(CreepMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_creepMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn creep_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, CreepMaterial>> {
        if index >= self.creep_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(CreepMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_creepMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn creep_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, CreepMaterial>> {
        (0..self.creep_materials_len())
            .map(move |i| self.creep_materials(i).expect("index below len"))
    }

    pub fn resize_creep_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_creepMaterials(self.raw.as_ptr(), count) }
    }

    /// Volume noise materials (VON_, v25+)
    pub fn volume_noise_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_volumeNoiseMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn volume_noise_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, VolumeNoiseMaterial>> {
        if index >= self.volume_noise_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(VolumeNoiseMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_volumeNoiseMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn volume_noise_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, VolumeNoiseMaterial>> {
        if index >= self.volume_noise_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(VolumeNoiseMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_volumeNoiseMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn volume_noise_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, VolumeNoiseMaterial>> {
        (0..self.volume_noise_materials_len())
            .map(move |i| self.volume_noise_materials(i).expect("index below len"))
    }

    pub fn resize_volume_noise_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_volumeNoiseMaterials(self.raw.as_ptr(), count) }
    }

    /// Splat terrain bake materials (STBM, v26+)
    pub fn stb_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_stbMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn stb_materials(&self, index: usize) -> Option<crate::support::Ref<'_, STBMaterial>> {
        if index >= self.stb_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(STBMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_stbMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn stb_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, STBMaterial>> {
        if index >= self.stb_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(STBMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_stbMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn stb_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, STBMaterial>> {
        (0..self.stb_materials_len()).map(move |i| self.stb_materials(i).expect("index below len"))
    }

    pub fn resize_stb_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_stbMaterials(self.raw.as_ptr(), count) }
    }

    /// Reflection materials (REF_, v28+)
    pub fn reflection_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_reflectionMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn reflection_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, ReflectionMaterial>> {
        if index >= self.reflection_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ReflectionMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_reflectionMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn reflection_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ReflectionMaterial>> {
        if index >= self.reflection_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ReflectionMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_reflectionMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn reflection_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ReflectionMaterial>> {
        (0..self.reflection_materials_len())
            .map(move |i| self.reflection_materials(i).expect("index below len"))
    }

    pub fn resize_reflection_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_reflectionMaterials(self.raw.as_ptr(), count) }
    }

    /// Lens flare materials (LFLR, v29+)
    pub fn lens_flare_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_lensFlareMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn lens_flare_materials(&self, index: usize) -> Option<crate::support::Ref<'_, LensFlare>> {
        if index >= self.lens_flare_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(LensFlare {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_lensFlareMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn lens_flare_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, LensFlare>> {
        if index >= self.lens_flare_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(LensFlare {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_lensFlareMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn lens_flare_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, LensFlare>> {
        (0..self.lens_flare_materials_len())
            .map(move |i| self.lens_flare_materials(i).expect("index below len"))
    }

    pub fn resize_lens_flare_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_lensFlareMaterials(self.raw.as_ptr(), count) }
    }

    /// Data-driven materials (MADD, v30+)
    pub fn data_driven_materials_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_dataDrivenMaterials_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn data_driven_materials(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, DataDrivenMaterial>> {
        if index >= self.data_driven_materials_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(DataDrivenMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_dataDrivenMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn data_driven_materials_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, DataDrivenMaterial>> {
        if index >= self.data_driven_materials_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(DataDrivenMaterial {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_dataDrivenMaterials_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn data_driven_materials_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, DataDrivenMaterial>> {
        (0..self.data_driven_materials_len())
            .map(move |i| self.data_driven_materials(i).expect("index below len"))
    }

    pub fn resize_data_driven_materials(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_dataDrivenMaterials(self.raw.as_ptr(), count) }
    }

    /// Particle emitters (PAR_)
    pub fn particle_emitters_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_particleEmitters(self.raw.as_ptr(), count) }
    }

    /// Particle emitter copies (PARC)
    pub fn particle_emitter_copies_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_particleEmitterCopies_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn particle_emitter_copies(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, ParticleEmitterCopy>> {
        if index >= self.particle_emitter_copies_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ParticleEmitterCopy {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_particleEmitterCopies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn particle_emitter_copies_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ParticleEmitterCopy>> {
        if index >= self.particle_emitter_copies_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ParticleEmitterCopy {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_particleEmitterCopies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn particle_emitter_copies_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ParticleEmitterCopy>> {
        (0..self.particle_emitter_copies_len())
            .map(move |i| self.particle_emitter_copies(i).expect("index below len"))
    }

    pub fn resize_particle_emitter_copies(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_particleEmitterCopies(self.raw.as_ptr(), count) }
    }

    /// Ribbon emitters (RIB_)
    pub fn ribbon_emitters_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_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_m3_M3Model_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_m3_M3Model_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_m3_M3Model_resize_ribbonEmitters(self.raw.as_ptr(), count) }
    }

    /// Projectors / decals (PROJ)
    pub fn projections_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_projections_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn projections(&self, index: usize) -> Option<crate::support::Ref<'_, Projector>> {
        if index >= self.projections_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Projector {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_projections_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn projections_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, Projector>> {
        if index >= self.projections_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Projector {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_projections_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn projections_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Projector>> {
        (0..self.projections_len()).map(move |i| self.projections(i).expect("index below len"))
    }

    pub fn resize_projections(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_projections(self.raw.as_ptr(), count) }
    }

    /// Forces (FOR_)
    pub fn forces_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_forces_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn forces(&self, index: usize) -> Option<crate::support::Ref<'_, Force>> {
        if index >= self.forces_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Force {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_forces_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn forces_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Force>> {
        if index >= self.forces_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Force {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_forces_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn forces_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Force>> {
        (0..self.forces_len()).map(move |i| self.forces(i).expect("index below len"))
    }

    pub fn resize_forces(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_forces(self.raw.as_ptr(), count) }
    }

    /// Warps (WRP_)
    pub fn warps_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_warps_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn warps(&self, index: usize) -> Option<crate::support::Ref<'_, Warp>> {
        if index >= self.warps_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(Warp {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_warps_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn warps_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, Warp>> {
        if index >= self.warps_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(Warp {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_warps_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn warps_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, Warp>> {
        (0..self.warps_len()).map(move |i| self.warps(i).expect("index below len"))
    }

    pub fn resize_warps(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_warps(self.raw.as_ptr(), count) }
    }

    /// View volumes (VVOL)
    pub fn view_volumes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_viewVolumes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn view_volumes(&self, index: usize) -> Option<crate::support::Ref<'_, ViewVolume>> {
        if index >= self.view_volumes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ViewVolume {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_viewVolumes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn view_volumes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ViewVolume>> {
        if index >= self.view_volumes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ViewVolume {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_viewVolumes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn view_volumes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ViewVolume>> {
        (0..self.view_volumes_len()).map(move |i| self.view_volumes(i).expect("index below len"))
    }

    pub fn resize_view_volumes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_viewVolumes(self.raw.as_ptr(), count) }
    }

    /// Rigid bodies (PHRB)
    pub fn rigid_bodies_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_rigidBodies_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn rigid_bodies(&self, index: usize) -> Option<crate::support::Ref<'_, RigidBody>> {
        if index >= self.rigid_bodies_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(RigidBody {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_rigidBodies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn rigid_bodies_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, RigidBody>> {
        if index >= self.rigid_bodies_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(RigidBody {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_rigidBodies_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn rigid_bodies_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, RigidBody>> {
        (0..self.rigid_bodies_len()).map(move |i| self.rigid_bodies(i).expect("index below len"))
    }

    pub fn resize_rigid_bodies(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_rigidBodies(self.raw.as_ptr(), count) }
    }

    /// Physics constraints (PHCT)
    pub fn physics_constraints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_physicsConstraints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn physics_constraints(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, PhysicsConstraint>> {
        if index >= self.physics_constraints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(PhysicsConstraint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_physicsConstraints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn physics_constraints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PhysicsConstraint>> {
        if index >= self.physics_constraints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(PhysicsConstraint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_physicsConstraints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn physics_constraints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsConstraint>> {
        (0..self.physics_constraints_len())
            .map(move |i| self.physics_constraints(i).expect("index below len"))
    }

    pub fn resize_physics_constraints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_physicsConstraints(self.raw.as_ptr(), count) }
    }

    /// Physics joints (PHYJ)
    pub fn physics_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_physicsJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn physics_joints(&self, index: usize) -> Option<crate::support::Ref<'_, PhysicsJoint>> {
        if index >= self.physics_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_m3_M3Model_get_physicsJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn physics_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, PhysicsJoint>> {
        if index >= self.physics_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_m3_M3Model_get_physicsJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn physics_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, PhysicsJoint>> {
        (0..self.physics_joints_len())
            .map(move |i| self.physics_joints(i).expect("index below len"))
    }

    pub fn resize_physics_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_physicsJoints(self.raw.as_ptr(), count) }
    }

    /// Cloth physics (PHCL, v28+)
    pub fn cloth_physics_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_clothPhysics_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn cloth_physics(&self, index: usize) -> Option<crate::support::Ref<'_, ClothPhysics>> {
        if index >= self.cloth_physics_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(ClothPhysics {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_clothPhysics_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn cloth_physics_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, ClothPhysics>> {
        if index >= self.cloth_physics_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(ClothPhysics {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_clothPhysics_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn cloth_physics_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, ClothPhysics>> {
        (0..self.cloth_physics_len()).map(move |i| self.cloth_physics(i).expect("index below len"))
    }

    pub fn resize_cloth_physics(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_clothPhysics(self.raw.as_ptr(), count) }
    }

    /// Two-joint IK solvers (IK2J)
    pub fn ik_two_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_ikTwoJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn ik_two_joints(&self, index: usize) -> Option<crate::support::Ref<'_, IKTwoJoint>> {
        if index >= self.ik_two_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(IKTwoJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_ikTwoJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn ik_two_joints_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, IKTwoJoint>> {
        if index >= self.ik_two_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(IKTwoJoint {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_ikTwoJoints_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn ik_two_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, IKTwoJoint>> {
        (0..self.ik_two_joints_len()).map(move |i| self.ik_two_joints(i).expect("index below len"))
    }

    pub fn resize_ik_two_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_ikTwoJoints(self.raw.as_ptr(), count) }
    }

    /// CCD IK solvers (IKCC, v24+)
    pub fn ik_ccd_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_ikCCD_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn ik_ccd(&self, index: usize) -> Option<crate::support::Ref<'_, IKCCD>> {
        if index >= self.ik_ccd_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(IKCCD {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_ikCCD_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn ik_ccd_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, IKCCD>> {
        if index >= self.ik_ccd_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(IKCCD {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_ikCCD_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn ik_ccd_iter(&self) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, IKCCD>> {
        (0..self.ik_ccd_len()).map(move |i| self.ik_ccd(i).expect("index below len"))
    }

    pub fn resize_ik_ccd(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_ikCCD(self.raw.as_ptr(), count) }
    }

    /// IK joints (IKJT)
    pub fn ik_joints_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_ikJoints_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn ik_joints(&self, index: usize) -> Option<crate::support::Ref<'_, IKJoint>> {
        if index >= self.ik_joints_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(IKJoint {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_ikJoints_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    pub fn ik_joints_mut(&mut self, index: usize) -> Option<crate::support::RefMut<'_, IKJoint>> {
        if index >= self.ik_joints_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(IKJoint {
                raw: core::ptr::NonNull::new_unchecked(ffi::whiteout_m3_M3Model_get_ikJoints_at(
                    self.raw.as_ptr(),
                    index,
                )),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn ik_joints_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, IKJoint>> {
        (0..self.ik_joints_len()).map(move |i| self.ik_joints(i).expect("index below len"))
    }

    pub fn resize_ik_joints(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_ikJoints(self.raw.as_ptr(), count) }
    }

    /// One-bone IK solvers (PAOB)
    pub fn one_bone_solvers_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_oneBoneSolvers_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn one_bone_solvers(&self, index: usize) -> Option<crate::support::Ref<'_, OneBoneSolver>> {
        if index >= self.one_bone_solvers_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(OneBoneSolver {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_oneBoneSolvers_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn one_bone_solvers_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, OneBoneSolver>> {
        if index >= self.one_bone_solvers_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(OneBoneSolver {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_oneBoneSolvers_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn one_bone_solvers_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, OneBoneSolver>> {
        (0..self.one_bone_solvers_len())
            .map(move |i| self.one_bone_solvers(i).expect("index below len"))
    }

    pub fn resize_one_bone_solvers(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_oneBoneSolvers(self.raw.as_ptr(), count) }
    }

    /// Turret behaviors (PATU)
    pub fn turret_behaviors_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_turretBehaviors_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn turret_behaviors(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, TurretBehavior>> {
        if index >= self.turret_behaviors_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TurretBehavior {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_turretBehaviors_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn turret_behaviors_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TurretBehavior>> {
        if index >= self.turret_behaviors_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TurretBehavior {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_turretBehaviors_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn turret_behaviors_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TurretBehavior>> {
        (0..self.turret_behaviors_len())
            .map(move |i| self.turret_behaviors(i).expect("index below len"))
    }

    pub fn resize_turret_behaviors(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_turretBehaviors(self.raw.as_ptr(), count) }
    }

    /// Trigger data (TRGD)
    pub fn trigger_data_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_triggerData_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn trigger_data(&self, index: usize) -> Option<crate::support::Ref<'_, TriggerData>> {
        if index >= self.trigger_data_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TriggerData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_triggerData_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn trigger_data_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TriggerData>> {
        if index >= self.trigger_data_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TriggerData {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_triggerData_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn trigger_data_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TriggerData>> {
        (0..self.trigger_data_len()).map(move |i| self.trigger_data(i).expect("index below len"))
    }

    pub fn resize_trigger_data(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_triggerData(self.raw.as_ptr(), count) }
    }

    /// Inverse bind-pose matrices (IREF)
    pub fn initial_reference_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_initialReference_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn initial_reference(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, InitialReference>> {
        if index >= self.initial_reference_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(InitialReference {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_initialReference_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn initial_reference_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, InitialReference>> {
        if index >= self.initial_reference_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(InitialReference {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_initialReference_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn initial_reference_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, InitialReference>> {
        (0..self.initial_reference_len())
            .map(move |i| self.initial_reference(i).expect("index below len"))
    }

    pub fn resize_initial_reference(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_initialReference(self.raw.as_ptr(), count) }
    }

    /// Tight hit-test shape (SSGS, inline)
    /// Borrows the field in place — no copy, no allocation.
    pub fn tight_hit_test_object(&self) -> crate::support::Ref<'_, HitTestShape> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(HitTestShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_tightHitTestObject(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn tight_hit_test_object_mut(&mut self) -> crate::support::RefMut<'_, HitTestShape> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(HitTestShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_tightHitTestObject(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Fuzzy hit-test shapes (SSGS)
    pub fn fuzzy_hit_test_objects_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_fuzzyHitTestObjects_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn fuzzy_hit_test_objects(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, HitTestShape>> {
        if index >= self.fuzzy_hit_test_objects_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(HitTestShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_fuzzyHitTestObjects_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn fuzzy_hit_test_objects_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, HitTestShape>> {
        if index >= self.fuzzy_hit_test_objects_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(HitTestShape {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_fuzzyHitTestObjects_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn fuzzy_hit_test_objects_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, HitTestShape>> {
        (0..self.fuzzy_hit_test_objects_len())
            .map(move |i| self.fuzzy_hit_test_objects(i).expect("index below len"))
    }

    pub fn resize_fuzzy_hit_test_objects(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_fuzzyHitTestObjects(self.raw.as_ptr(), count) }
    }

    /// Attachment volumes (ATVL)
    pub fn attachment_volumes_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_attachmentVolumes_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn attachment_volumes(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, AttachmentVolume>> {
        if index >= self.attachment_volumes_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(AttachmentVolume {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_attachmentVolumes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn attachment_volumes_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, AttachmentVolume>> {
        if index >= self.attachment_volumes_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(AttachmentVolume {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_attachmentVolumes_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn attachment_volumes_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, AttachmentVolume>> {
        (0..self.attachment_volumes_len())
            .map(move |i| self.attachment_volumes(i).expect("index below len"))
    }

    pub fn resize_attachment_volumes(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_attachmentVolumes(self.raw.as_ptr(), count) }
    }

    /// Attachment volume addon 0 (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn attachment_volumes_addon_0(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon0_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon0_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_volumes_addon_0_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon0_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon0_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_volumes_addon_0(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_attachmentVolumesAddon0(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_attachment_volumes_addon_0(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_attachmentVolumesAddon0(self.raw.as_ptr(), count) }
    }

    /// Attachment volume addon 1 (U16_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn attachment_volumes_addon_1(&self) -> &[u16] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon1_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon1_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_volumes_addon_1_mut(&mut self) -> &mut [u16] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon1_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_attachmentVolumesAddon1_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_volumes_addon_1(&mut self, values: &[u16]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_attachmentVolumesAddon1(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_attachment_volumes_addon_1(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_attachmentVolumesAddon1(self.raw.as_ptr(), count) }
    }

    /// Billboard behaviors (BBSC)
    pub fn billboard_behaviors_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_billboardBehaviors_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn billboard_behaviors(
        &self,
        index: usize,
    ) -> Option<crate::support::Ref<'_, BillboardBehavior>> {
        if index >= self.billboard_behaviors_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(BillboardBehavior {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_billboardBehaviors_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn billboard_behaviors_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, BillboardBehavior>> {
        if index >= self.billboard_behaviors_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(BillboardBehavior {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_billboardBehaviors_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn billboard_behaviors_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, BillboardBehavior>> {
        (0..self.billboard_behaviors_len())
            .map(move |i| self.billboard_behaviors(i).expect("index below len"))
    }

    pub fn resize_billboard_behaviors(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_billboardBehaviors(self.raw.as_ptr(), count) }
    }

    /// Trailing models (TMD_, defunct)
    pub fn trailing_models_len(&self) -> usize {
        // SAFETY: scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_trailingModels_count(self.raw.as_ptr()) }
    }

    /// Borrows element `index` in place. `None` when out of range.
    pub fn trailing_models(&self, index: usize) -> Option<crate::support::Ref<'_, TrailingModel>> {
        if index >= self.trailing_models_len() {
            return None;
        }
        // SAFETY: index checked above; the pointer is interior to `self`.
        unsafe {
            Some(crate::support::Ref::new(TrailingModel {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_trailingModels_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    pub fn trailing_models_mut(
        &mut self,
        index: usize,
    ) -> Option<crate::support::RefMut<'_, TrailingModel>> {
        if index >= self.trailing_models_len() {
            return None;
        }
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            Some(crate::support::RefMut::new(TrailingModel {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3Model_get_trailingModels_at(self.raw.as_ptr(), index),
                ),
            }))
        }
    }

    /// Iterate the elements, borrowing each in turn.
    pub fn trailing_models_iter(
        &self,
    ) -> impl ExactSizeIterator<Item = crate::support::Ref<'_, TrailingModel>> {
        (0..self.trailing_models_len())
            .map(move |i| self.trailing_models(i).expect("index below len"))
    }

    pub fn resize_trailing_models(&mut self, count: usize) {
        // SAFETY: exclusive access, so no borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_trailingModels(self.raw.as_ptr(), count) }
    }

    /// Hash for .m3a animation file binding
    pub fn m_3a_anim_hash(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_get_m3aAnimHash(self.raw.as_ptr()) }
    }

    pub fn set_m_3a_anim_hash(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3Model_set_m3aAnimHash(self.raw.as_ptr(), value) }
    }

    /// Additional .m3a hashes (U32_)
    /// Zero-copy view of the underlying `std::vector`.
    pub fn m_3a_anim_hashes(&self) -> &[u32] {
        // SAFETY: `_data`/`_count` describe one contiguous C++
        // allocation, borrowed for as long as `self` is.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_m3aAnimHashes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_m3aAnimHashes_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_3a_anim_hashes_mut(&mut self) -> &mut [u32] {
        // SAFETY: as above; `&mut self` rules out aliasing and resizing.
        unsafe {
            let n = ffi::whiteout_m3_M3Model_get_m3aAnimHashes_count(self.raw.as_ptr());
            let p = ffi::whiteout_m3_M3Model_get_m3aAnimHashes_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_m_3a_anim_hashes(&mut self, values: &[u32]) {
        // SAFETY: the native side copies `values` before returning.
        unsafe {
            ffi::whiteout_m3_M3Model_assign_m3aAnimHashes(
                self.raw.as_ptr(),
                values.as_ptr() as *const _,
                values.len(),
            )
        }
    }

    pub fn resize_m_3a_anim_hashes(&mut self, count: usize) {
        // SAFETY: reallocation is safe here precisely because
        // `&mut self` means no slice borrow is outstanding.
        unsafe { ffi::whiteout_m3_M3Model_resize_m3aAnimHashes(self.raw.as_ptr(), count) }
    }
}

impl Default for Model {
    fn default() -> Self {
        Self::new()
    }
}

/// Parser for M3 model files
///
/// The Parser reads binary M3 files and converts them into the Model structure. It supports multiple parsing modes for error handling.
///
/// Uses the PImpl (Pointer to Implementation) idiom to hide implementation details.
pub struct Parser {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Parser>,
}

impl Drop for Parser {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Parser_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_M3Parser) -> 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_m3_M3Parser_new();
            Self::from_raw(raw).expect("native Parser allocation failed")
        }
    }

    /// Parse an M3 file from disk @param filePath Path to the M3 file @return Parsed M3 model data @throws std::runtime_error If file cannot be opened or parsing fails in strict mode
    pub fn parse_file(&mut self, 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_m3_M3Parser_parse(
                self.raw.as_ptr(),
                file_path_cstr.as_ptr(),
            ))
        }
    }

    /// Parse an M3 file from memory buffer @param buffer Memory buffer containing M3 data @return Parsed M3 model data @throws std::runtime_error If parsing fails in strict mode
    pub fn parse(&mut self, buffer: &[u8]) -> Option<Model> {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            Model::from_raw(ffi::whiteout_m3_M3Parser_parse_buffer(
                self.raw.as_ptr(),
                buffer.as_ptr(),
                buffer.len(),
            ))
        }
    }

    /// Check if parsing encountered any issues @return True if there were warnings or recoverable errors
    pub fn has_issues(&self) -> bool {
        // SAFETY: handle is live for the duration of the call.
        unsafe { ffi::whiteout_m3_M3Parser_hasIssues(self.raw.as_ptr()) != 0 }
    }

    /// Get list of issues encountered during parsing @return Vector of issue description strings
    pub fn issues(&self) -> Vec<String> {
        // SAFETY: index stays below the reported count.
        unsafe {
            let n = ffi::whiteout_m3_M3Parser_getIssues_count(self.raw.as_ptr());
            (0..n)
                .map(|i| {
                    crate::support::take_string(ffi::whiteout_m3_M3Parser_getIssues_at(
                        self.raw.as_ptr(),
                        i,
                    ))
                })
                .collect()
        }
    }
}

impl Default for Parser {
    fn default() -> Self {
        Self::new()
    }
}

/// Writer for M3 model files
///
/// Writes Model structures to disk in binary M3 format. Uses the PImpl (Pointer to Implementation) idiom to hide implementation details.
pub struct Writer {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3Writer>,
}

impl Drop for Writer {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3Writer_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_M3Writer) -> 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_m3_M3Writer_new();
            Self::from_raw(raw).expect("native Writer allocation failed")
        }
    }

    /// Write an M3 model to a file on disk @param filePath Output file path @param model Model data to serialize @throws std::runtime_error If file cannot be created or writing fails
    pub fn write_file(&mut self, 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_m3_M3Writer_write(
                self.raw.as_ptr(),
                file_path_cstr.as_ptr(),
                model.raw.as_ptr(),
            );
        }
    }

    /// Write an M3 model to a byte buffer @param model Model data to serialize @return Byte buffer containing the M3 file data
    pub fn write(&mut self, model: &Model) -> Bytes {
        // SAFETY: handle is live for the duration of the call.
        unsafe {
            Bytes::from_raw(ffi::whiteout_m3_M3Writer_write_model(
                self.raw.as_ptr(),
                model.raw.as_ptr(),
            ))
            .unwrap_or_else(Bytes::empty)
        }
    }
}

impl Default for Writer {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefF32 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefF32>,
}

impl Drop for AnimRefF32 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefF32 {
    /// # 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_M3AnimRefF32) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefF32 { 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 AnimRefF32 {}

impl core::fmt::Debug for AnimRefF32 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefF32").finish_non_exhaustive()
    }
}

impl AnimRefF32 {
    /// # 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_m3_M3AnimRefF32_new();
            Self::from_raw(raw).expect("native AnimRefF32 allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_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_m3_M3AnimRefF32_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_value(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_get_initValue(self.raw.as_ptr()) }
    }

    pub fn set_init_value(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_set_initValue(self.raw.as_ptr(), value) }
    }

    /// Null/reset value
    pub fn null_value(&self) -> f32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_get_nullValue(self.raw.as_ptr()) }
    }

    pub fn set_null_value(&mut self, value: f32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_set_nullValue(self.raw.as_ptr(), value) }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefF32_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefF32 {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefVector3f {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefVector3f>,
}

impl Drop for AnimRefVector3f {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefVector3f {
    /// # 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_M3AnimRefVector3f) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefVector3f { 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 AnimRefVector3f {}

impl core::fmt::Debug for AnimRefVector3f {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefVector3f").finish_non_exhaustive()
    }
}

impl AnimRefVector3f {
    /// # 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_m3_M3AnimRefVector3f_new();
            Self::from_raw(raw).expect("native AnimRefVector3f allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_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_m3_M3AnimRefVector3f_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_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_m3_M3AnimRefVector3f_get_initValue(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_init_value(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefVector3f_set_initValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Null/reset value
    pub fn null_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_m3_M3AnimRefVector3f_get_nullValue(self.raw.as_ptr())
                as *const crate::math::Vector3f)
        }
    }

    pub fn set_null_value(&mut self, value: crate::math::Vector3f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefVector3f_set_nullValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector3f as *const _,
            )
        }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector3f_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefVector3f {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefM3ColorBGRA {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefM3ColorBGRA>,
}

impl Drop for AnimRefM3ColorBGRA {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefM3ColorBGRA {
    /// # 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_M3AnimRefM3ColorBGRA) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefM3ColorBGRA { 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 AnimRefM3ColorBGRA {}

impl core::fmt::Debug for AnimRefM3ColorBGRA {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefM3ColorBGRA").finish_non_exhaustive()
    }
}

impl AnimRefM3ColorBGRA {
    /// # 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_m3_M3AnimRefM3ColorBGRA_new();
            Self::from_raw(raw).expect("native AnimRefM3ColorBGRA allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_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_m3_M3AnimRefM3ColorBGRA_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    /// Borrows the field in place — no copy, no allocation.
    pub fn init_value(&self) -> crate::support::Ref<'_, ColorBGRA> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(ColorBGRA {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_initValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn init_value_mut(&mut self) -> crate::support::RefMut<'_, ColorBGRA> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(ColorBGRA {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_initValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Null/reset value
    /// Borrows the field in place — no copy, no allocation.
    pub fn null_value(&self) -> crate::support::Ref<'_, ColorBGRA> {
        // SAFETY: an interior pointer into `self`, valid for this
        // borrow and never freed by the `Ref`.
        unsafe {
            crate::support::Ref::new(ColorBGRA {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_nullValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn null_value_mut(&mut self) -> crate::support::RefMut<'_, ColorBGRA> {
        // SAFETY: as above; `&mut self` guarantees exclusivity.
        unsafe {
            crate::support::RefMut::new(ColorBGRA {
                raw: core::ptr::NonNull::new_unchecked(
                    ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_nullValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3ColorBGRA_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefM3ColorBGRA {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefU16 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefU16>,
}

impl Drop for AnimRefU16 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefU16 {
    /// # 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_M3AnimRefU16) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefU16 { 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 AnimRefU16 {}

impl core::fmt::Debug for AnimRefU16 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefU16").finish_non_exhaustive()
    }
}

impl AnimRefU16 {
    /// # 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_m3_M3AnimRefU16_new();
            Self::from_raw(raw).expect("native AnimRefU16 allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_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_m3_M3AnimRefU16_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_value(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_get_initValue(self.raw.as_ptr()) }
    }

    pub fn set_init_value(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_set_initValue(self.raw.as_ptr(), value) }
    }

    /// Null/reset value
    pub fn null_value(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_get_nullValue(self.raw.as_ptr()) }
    }

    pub fn set_null_value(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_set_nullValue(self.raw.as_ptr(), value) }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU16_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefU16 {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefVector2f {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefVector2f>,
}

impl Drop for AnimRefVector2f {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefVector2f {
    /// # 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_M3AnimRefVector2f) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefVector2f { 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 AnimRefVector2f {}

impl core::fmt::Debug for AnimRefVector2f {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefVector2f").finish_non_exhaustive()
    }
}

impl AnimRefVector2f {
    /// # 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_m3_M3AnimRefVector2f_new();
            Self::from_raw(raw).expect("native AnimRefVector2f allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_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_m3_M3AnimRefVector2f_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_value(&self) -> crate::math::Vector2f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3AnimRefVector2f_get_initValue(self.raw.as_ptr())
                as *const crate::math::Vector2f)
        }
    }

    pub fn set_init_value(&mut self, value: crate::math::Vector2f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefVector2f_set_initValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector2f as *const _,
            )
        }
    }

    /// Null/reset value
    pub fn null_value(&self) -> crate::math::Vector2f {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3AnimRefVector2f_get_nullValue(self.raw.as_ptr())
                as *const crate::math::Vector2f)
        }
    }

    pub fn set_null_value(&mut self, value: crate::math::Vector2f) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefVector2f_set_nullValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Vector2f as *const _,
            )
        }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefVector2f_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefVector2f {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefU32 {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefU32>,
}

impl Drop for AnimRefU32 {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefU32 {
    /// # 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_M3AnimRefU32) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefU32 { 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 AnimRefU32 {}

impl core::fmt::Debug for AnimRefU32 {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefU32").finish_non_exhaustive()
    }
}

impl AnimRefU32 {
    /// # 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_m3_M3AnimRefU32_new();
            Self::from_raw(raw).expect("native AnimRefU32 allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_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_m3_M3AnimRefU32_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_value(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_get_initValue(self.raw.as_ptr()) }
    }

    pub fn set_init_value(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_set_initValue(self.raw.as_ptr(), value) }
    }

    /// Null/reset value
    pub fn null_value(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_get_nullValue(self.raw.as_ptr()) }
    }

    pub fn set_null_value(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_set_nullValue(self.raw.as_ptr(), value) }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefU32_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefU32 {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefQuaternion {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefQuaternion>,
}

impl Drop for AnimRefQuaternion {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefQuaternion {
    /// # 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_M3AnimRefQuaternion) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefQuaternion { 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 AnimRefQuaternion {}

impl core::fmt::Debug for AnimRefQuaternion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefQuaternion").finish_non_exhaustive()
    }
}

impl AnimRefQuaternion {
    /// # 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_m3_M3AnimRefQuaternion_new();
            Self::from_raw(raw).expect("native AnimRefQuaternion allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_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_m3_M3AnimRefQuaternion_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    pub fn init_value(&self) -> crate::math::Quaternion {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3AnimRefQuaternion_get_initValue(self.raw.as_ptr())
                as *const crate::math::Quaternion)
        }
    }

    pub fn set_init_value(&mut self, value: crate::math::Quaternion) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefQuaternion_set_initValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Quaternion as *const _,
            )
        }
    }

    /// Null/reset value
    pub fn null_value(&self) -> crate::math::Quaternion {
        // SAFETY: the getter returns an interior pointer to a
        // layout-identical POD; we copy it out immediately.
        unsafe {
            *(ffi::whiteout_m3_M3AnimRefQuaternion_get_nullValue(self.raw.as_ptr())
                as *const crate::math::Quaternion)
        }
    }

    pub fn set_null_value(&mut self, value: crate::math::Quaternion) {
        // SAFETY: as above, in the other direction.
        unsafe {
            ffi::whiteout_m3_M3AnimRefQuaternion_set_nullValue(
                self.raw.as_ptr(),
                &value as *const crate::math::Quaternion as *const _,
            )
        }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefQuaternion_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefQuaternion {
    fn default() -> Self {
        Self::new()
    }
}

/// Animatable reference holding a default value and animation link
///
/// Holds both a constant default value and a link to keyframed animation data. If animId == 0, the property is not animated — use initValue as a constant. Otherwise, resolve through STC_.animIds to locate keyframe data. Total size depends on sizeof(T): 12 + 2*sizeof(T) + 4 bytes.
///
/// @tparam T The value type (f32, Vector3f, Quaternion, ColorBGRA, Extent, etc.)
pub struct AnimRefM3Extent {
    pub(crate) raw: core::ptr::NonNull<ffi::whiteout_M3AnimRefM3Extent>,
}

impl Drop for AnimRefM3Extent {
    fn drop(&mut self) {
        // SAFETY: `raw` came from a native constructor and Drop runs once.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_delete(self.raw.as_ptr()) }
    }
}

impl AnimRefM3Extent {
    /// # 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_M3AnimRefM3Extent) -> Option<Self> {
        core::ptr::NonNull::new(raw).map(|raw| AnimRefM3Extent { 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 AnimRefM3Extent {}

impl core::fmt::Debug for AnimRefM3Extent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("AnimRefM3Extent").finish_non_exhaustive()
    }
}

impl AnimRefM3Extent {
    /// # 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_m3_M3AnimRefM3Extent_new();
            Self::from_raw(raw).expect("native AnimRefM3Extent allocation failed")
        }
    }

    /// Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier
    pub fn interp_type(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_get_interpType(self.raw.as_ptr()) }
    }

    pub fn set_interp_type(&mut self, value: u16) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_set_interpType(self.raw.as_ptr(), value) }
    }

    /// Animation flags
    pub fn flags(&self) -> u16 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_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_m3_M3AnimRefM3Extent_set_flags(self.raw.as_ptr(), value) }
    }

    /// Animation identifier (links to STC animation data; 0=not animated)
    pub fn anim_id(&self) -> u32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_get_animId(self.raw.as_ptr()) }
    }

    pub fn set_anim_id(&mut self, value: u32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_set_animId(self.raw.as_ptr(), value) }
    }

    /// Initial/default value (used when not animated)
    /// Borrows the field in place — no copy, no allocation.
    pub fn init_value(&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_m3_M3AnimRefM3Extent_get_initValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn init_value_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_m3_M3AnimRefM3Extent_get_initValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Null/reset value
    /// Borrows the field in place — no copy, no allocation.
    pub fn null_value(&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_m3_M3AnimRefM3Extent_get_nullValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    pub fn null_value_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_m3_M3AnimRefM3Extent_get_nullValue(self.raw.as_ptr()),
                ),
            })
        }
    }

    /// Typically -1
    pub fn unused(&self) -> i32 {
        // SAFETY: plain scalar read through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_get_unused(self.raw.as_ptr()) }
    }

    pub fn set_unused(&mut self, value: i32) {
        // SAFETY: plain scalar write through a live handle.
        unsafe { ffi::whiteout_m3_M3AnimRefM3Extent_set_unused(self.raw.as_ptr(), value) }
    }
}

impl Default for AnimRefM3Extent {
    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_M3ColorBGRA {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ColorBGR {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Extent {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Event {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Sequence {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3SubTrackContainer {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimationGroup {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimationState {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3BoneAnimationSet {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ParticleEmitter {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ParticleEmitterCopy {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3SplineRibbon {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3RibbonEmitter {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Projector {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3MaterialMap {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3TextureLayer {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3StandardMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3DisplacementMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3CompositeSection {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3CompositeMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3TerrainMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3VolumeMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3HairMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3VolumeNoiseMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3CreepMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3STBMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ReflectionMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3SubFlare {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3LensFlare {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3DataDrivenProperty {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3DataDrivenGroup {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3DataDrivenProperties {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3StandardMaterialConversion {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3DataDrivenMaterial {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Bone {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Region {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Batch {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3MeshSection {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3MeshDivision {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3InitialReference {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AttachmentPoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3HitTestShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AttachmentVolume {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3TriggerData {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3TurretBehavior {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3BillboardBehavior {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3IKJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3IKTwoJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3IKCCD {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3OneBoneSolver {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ShadowBox {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ViewVolume {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3TrailingModel {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Force {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Warp {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ConvexHullHalfEdge {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsMeshBvhNode {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsMeshTriangle {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsMeshEdge {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsShape {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3RigidBody {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsJoint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3PhysicsConstraint {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ClothCollider {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ClothProxy {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3ClothPhysics {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Light {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Camera {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Model {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Parser {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3Writer {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefF32 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefVector3f {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefM3ColorBGRA {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefU16 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefVector2f {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefU32 {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefQuaternion {
        _private: [u8; 0],
    }
    #[repr(C)]
    pub struct whiteout_M3AnimRefM3Extent {
        _private: [u8; 0],
    }

    extern "C" {
        // ColorBGRA
        pub fn whiteout_m3_M3ColorBGRA_new() -> *mut whiteout_M3ColorBGRA;
        pub fn whiteout_m3_M3ColorBGRA_delete(self_: *mut whiteout_M3ColorBGRA);
        pub fn whiteout_m3_M3ColorBGRA_get_b(self_: *mut whiteout_M3ColorBGRA) -> u8;
        pub fn whiteout_m3_M3ColorBGRA_set_b(self_: *mut whiteout_M3ColorBGRA, value: u8);
        pub fn whiteout_m3_M3ColorBGRA_get_g(self_: *mut whiteout_M3ColorBGRA) -> u8;
        pub fn whiteout_m3_M3ColorBGRA_set_g(self_: *mut whiteout_M3ColorBGRA, value: u8);
        pub fn whiteout_m3_M3ColorBGRA_get_r(self_: *mut whiteout_M3ColorBGRA) -> u8;
        pub fn whiteout_m3_M3ColorBGRA_set_r(self_: *mut whiteout_M3ColorBGRA, value: u8);
        pub fn whiteout_m3_M3ColorBGRA_get_a(self_: *mut whiteout_M3ColorBGRA) -> u8;
        pub fn whiteout_m3_M3ColorBGRA_set_a(self_: *mut whiteout_M3ColorBGRA, value: u8);
        // ColorBGR
        pub fn whiteout_m3_M3ColorBGR_new() -> *mut whiteout_M3ColorBGR;
        pub fn whiteout_m3_M3ColorBGR_delete(self_: *mut whiteout_M3ColorBGR);
        pub fn whiteout_m3_M3ColorBGR_get_b(self_: *mut whiteout_M3ColorBGR) -> u8;
        pub fn whiteout_m3_M3ColorBGR_set_b(self_: *mut whiteout_M3ColorBGR, value: u8);
        pub fn whiteout_m3_M3ColorBGR_get_g(self_: *mut whiteout_M3ColorBGR) -> u8;
        pub fn whiteout_m3_M3ColorBGR_set_g(self_: *mut whiteout_M3ColorBGR, value: u8);
        pub fn whiteout_m3_M3ColorBGR_get_r(self_: *mut whiteout_M3ColorBGR) -> u8;
        pub fn whiteout_m3_M3ColorBGR_set_r(self_: *mut whiteout_M3ColorBGR, value: u8);
        // Extent
        pub fn whiteout_m3_M3Extent_new() -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3Extent_delete(self_: *mut whiteout_M3Extent);
        pub fn whiteout_m3_M3Extent_get_min(
            self_: *mut whiteout_M3Extent,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3Extent_set_min(
            self_: *mut whiteout_M3Extent,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3Extent_get_max(
            self_: *mut whiteout_M3Extent,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3Extent_set_max(
            self_: *mut whiteout_M3Extent,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3Extent_get_radius(self_: *mut whiteout_M3Extent) -> f32;
        pub fn whiteout_m3_M3Extent_set_radius(self_: *mut whiteout_M3Extent, value: f32);
        // Event
        pub fn whiteout_m3_M3Event_new() -> *mut whiteout_M3Event;
        pub fn whiteout_m3_M3Event_delete(self_: *mut whiteout_M3Event);
        pub fn whiteout_m3_M3Event_get_name(self_: *mut whiteout_M3Event) -> RawCString;
        pub fn whiteout_m3_M3Event_set_name(
            self_: *mut whiteout_M3Event,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Event_get_unknown(self_: *mut whiteout_M3Event) -> u32;
        pub fn whiteout_m3_M3Event_set_unknown(self_: *mut whiteout_M3Event, value: u32);
        pub fn whiteout_m3_M3Event_get_boneIndex(self_: *mut whiteout_M3Event) -> u16;
        pub fn whiteout_m3_M3Event_set_boneIndex(self_: *mut whiteout_M3Event, value: u16);
        pub fn whiteout_m3_M3Event_get_padding(self_: *mut whiteout_M3Event) -> u16;
        pub fn whiteout_m3_M3Event_set_padding(self_: *mut whiteout_M3Event, value: u16);
        pub fn whiteout_m3_M3Event_get_eventType(self_: *mut whiteout_M3Event) -> u32;
        pub fn whiteout_m3_M3Event_set_eventType(self_: *mut whiteout_M3Event, value: u32);
        pub fn whiteout_m3_M3Event_get_optionString(self_: *mut whiteout_M3Event) -> RawCString;
        pub fn whiteout_m3_M3Event_set_optionString(
            self_: *mut whiteout_M3Event,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Event_get_rttChannelIndex(self_: *mut whiteout_M3Event) -> u32;
        pub fn whiteout_m3_M3Event_set_rttChannelIndex(self_: *mut whiteout_M3Event, value: u32);
        pub fn whiteout_m3_M3Event_get_extraParameter(self_: *mut whiteout_M3Event) -> u32;
        pub fn whiteout_m3_M3Event_set_extraParameter(self_: *mut whiteout_M3Event, value: u32);
        // Sequence
        pub fn whiteout_m3_M3Sequence_new() -> *mut whiteout_M3Sequence;
        pub fn whiteout_m3_M3Sequence_delete(self_: *mut whiteout_M3Sequence);
        pub fn whiteout_m3_M3Sequence_get_id(self_: *mut whiteout_M3Sequence) -> i32;
        pub fn whiteout_m3_M3Sequence_set_id(self_: *mut whiteout_M3Sequence, value: i32);
        pub fn whiteout_m3_M3Sequence_get_index(self_: *mut whiteout_M3Sequence) -> i32;
        pub fn whiteout_m3_M3Sequence_set_index(self_: *mut whiteout_M3Sequence, value: i32);
        pub fn whiteout_m3_M3Sequence_get_name(self_: *mut whiteout_M3Sequence) -> RawCString;
        pub fn whiteout_m3_M3Sequence_set_name(
            self_: *mut whiteout_M3Sequence,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Sequence_get_startFrame(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_startFrame(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_endFrame(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_endFrame(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_moveSpeed(self_: *mut whiteout_M3Sequence) -> f32;
        pub fn whiteout_m3_M3Sequence_set_moveSpeed(self_: *mut whiteout_M3Sequence, value: f32);
        pub fn whiteout_m3_M3Sequence_get_flags(self_: *mut whiteout_M3Sequence) -> i32;
        pub fn whiteout_m3_M3Sequence_set_flags(self_: *mut whiteout_M3Sequence, value: i32);
        pub fn whiteout_m3_M3Sequence_get_frequency(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_frequency(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_replayStart(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_replayStart(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_replayEnd(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_replayEnd(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_blendTime(self_: *mut whiteout_M3Sequence) -> u32;
        pub fn whiteout_m3_M3Sequence_set_blendTime(self_: *mut whiteout_M3Sequence, value: u32);
        pub fn whiteout_m3_M3Sequence_get_bounds(
            self_: *mut whiteout_M3Sequence,
        ) -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3Sequence_set_bounds(
            self_: *mut whiteout_M3Sequence,
            value: *const whiteout_M3Extent,
        );
        pub fn whiteout_m3_M3Sequence_get_animationSets_count(
            self_: *mut whiteout_M3Sequence,
        ) -> usize;
        pub fn whiteout_m3_M3Sequence_resize_animationSets(
            self_: *mut whiteout_M3Sequence,
            count: usize,
        );
        pub fn whiteout_m3_M3Sequence_get_animationSets_data(
            self_: *mut whiteout_M3Sequence,
        ) -> *const u8;
        pub fn whiteout_m3_M3Sequence_assign_animationSets(
            self_: *mut whiteout_M3Sequence,
            data: *const u8,
            count: usize,
        );
        // SubTrackContainer
        pub fn whiteout_m3_M3SubTrackContainer_new() -> *mut whiteout_M3SubTrackContainer;
        pub fn whiteout_m3_M3SubTrackContainer_delete(self_: *mut whiteout_M3SubTrackContainer);
        pub fn whiteout_m3_M3SubTrackContainer_get_name(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> RawCString;
        pub fn whiteout_m3_M3SubTrackContainer_set_name(
            self_: *mut whiteout_M3SubTrackContainer,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_runsConcurrent(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> u16;
        pub fn whiteout_m3_M3SubTrackContainer_set_runsConcurrent(
            self_: *mut whiteout_M3SubTrackContainer,
            value: u16,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animPriority(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> u16;
        pub fn whiteout_m3_M3SubTrackContainer_set_animPriority(
            self_: *mut whiteout_M3SubTrackContainer,
            value: u16,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animationStateIndex(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> u16;
        pub fn whiteout_m3_M3SubTrackContainer_set_animationStateIndex(
            self_: *mut whiteout_M3SubTrackContainer,
            value: u16,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animationStateIndexCopy(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> u16;
        pub fn whiteout_m3_M3SubTrackContainer_set_animationStateIndexCopy(
            self_: *mut whiteout_M3SubTrackContainer,
            value: u16,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animIds_count(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> usize;
        pub fn whiteout_m3_M3SubTrackContainer_resize_animIds(
            self_: *mut whiteout_M3SubTrackContainer,
            count: usize,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animIds_data(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> *const u32;
        pub fn whiteout_m3_M3SubTrackContainer_assign_animIds(
            self_: *mut whiteout_M3SubTrackContainer,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animRefs_count(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> usize;
        pub fn whiteout_m3_M3SubTrackContainer_resize_animRefs(
            self_: *mut whiteout_M3SubTrackContainer,
            count: usize,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_animRefs_data(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> *const u32;
        pub fn whiteout_m3_M3SubTrackContainer_assign_animRefs(
            self_: *mut whiteout_M3SubTrackContainer,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3SubTrackContainer_get_unknown(
            self_: *mut whiteout_M3SubTrackContainer,
        ) -> u32;
        pub fn whiteout_m3_M3SubTrackContainer_set_unknown(
            self_: *mut whiteout_M3SubTrackContainer,
            value: u32,
        );
        // AnimationGroup
        pub fn whiteout_m3_M3AnimationGroup_new() -> *mut whiteout_M3AnimationGroup;
        pub fn whiteout_m3_M3AnimationGroup_delete(self_: *mut whiteout_M3AnimationGroup);
        pub fn whiteout_m3_M3AnimationGroup_get_name(
            self_: *mut whiteout_M3AnimationGroup,
        ) -> RawCString;
        pub fn whiteout_m3_M3AnimationGroup_set_name(
            self_: *mut whiteout_M3AnimationGroup,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3AnimationGroup_get_subtrackIndices_count(
            self_: *mut whiteout_M3AnimationGroup,
        ) -> usize;
        pub fn whiteout_m3_M3AnimationGroup_resize_subtrackIndices(
            self_: *mut whiteout_M3AnimationGroup,
            count: usize,
        );
        pub fn whiteout_m3_M3AnimationGroup_get_subtrackIndices_data(
            self_: *mut whiteout_M3AnimationGroup,
        ) -> *const u32;
        pub fn whiteout_m3_M3AnimationGroup_assign_subtrackIndices(
            self_: *mut whiteout_M3AnimationGroup,
            data: *const u32,
            count: usize,
        );
        // AnimationState
        pub fn whiteout_m3_M3AnimationState_new() -> *mut whiteout_M3AnimationState;
        pub fn whiteout_m3_M3AnimationState_delete(self_: *mut whiteout_M3AnimationState);
        pub fn whiteout_m3_M3AnimationState_get_animIds_count(
            self_: *mut whiteout_M3AnimationState,
        ) -> usize;
        pub fn whiteout_m3_M3AnimationState_resize_animIds(
            self_: *mut whiteout_M3AnimationState,
            count: usize,
        );
        pub fn whiteout_m3_M3AnimationState_get_animIds_data(
            self_: *mut whiteout_M3AnimationState,
        ) -> *const u32;
        pub fn whiteout_m3_M3AnimationState_assign_animIds(
            self_: *mut whiteout_M3AnimationState,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3AnimationState_unknown_size() -> usize;
        pub fn whiteout_m3_M3AnimationState_get_unknown_at(
            self_: *mut whiteout_M3AnimationState,
            index: usize,
        ) -> u8;
        pub fn whiteout_m3_M3AnimationState_set_unknown_at(
            self_: *mut whiteout_M3AnimationState,
            index: usize,
            value: u8,
        );
        // BoneAnimationSet
        pub fn whiteout_m3_M3BoneAnimationSet_new() -> *mut whiteout_M3BoneAnimationSet;
        pub fn whiteout_m3_M3BoneAnimationSet_delete(self_: *mut whiteout_M3BoneAnimationSet);
        pub fn whiteout_m3_M3BoneAnimationSet_get_animationSequenceIndex(
            self_: *mut whiteout_M3BoneAnimationSet,
        ) -> u16;
        pub fn whiteout_m3_M3BoneAnimationSet_set_animationSequenceIndex(
            self_: *mut whiteout_M3BoneAnimationSet,
            value: u16,
        );
        pub fn whiteout_m3_M3BoneAnimationSet_get_fallbackSequenceIndex(
            self_: *mut whiteout_M3BoneAnimationSet,
        ) -> u16;
        pub fn whiteout_m3_M3BoneAnimationSet_set_fallbackSequenceIndex(
            self_: *mut whiteout_M3BoneAnimationSet,
            value: u16,
        );
        pub fn whiteout_m3_M3BoneAnimationSet_get_name(
            self_: *mut whiteout_M3BoneAnimationSet,
        ) -> RawCString;
        pub fn whiteout_m3_M3BoneAnimationSet_set_name(
            self_: *mut whiteout_M3BoneAnimationSet,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3BoneAnimationSet_get_splitItems_count(
            self_: *mut whiteout_M3BoneAnimationSet,
        ) -> usize;
        pub fn whiteout_m3_M3BoneAnimationSet_resize_splitItems(
            self_: *mut whiteout_M3BoneAnimationSet,
            count: usize,
        );
        pub fn whiteout_m3_M3BoneAnimationSet_get_splitItems_data(
            self_: *mut whiteout_M3BoneAnimationSet,
        ) -> *const u16;
        pub fn whiteout_m3_M3BoneAnimationSet_assign_splitItems(
            self_: *mut whiteout_M3BoneAnimationSet,
            data: *const u16,
            count: usize,
        );
        // ParticleEmitter
        pub fn whiteout_m3_M3ParticleEmitter_new() -> *mut whiteout_M3ParticleEmitter;
        pub fn whiteout_m3_M3ParticleEmitter_delete(self_: *mut whiteout_M3ParticleEmitter);
        pub fn whiteout_m3_M3ParticleEmitter_get_boneIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_boneIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_materialIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_materialIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_additionalFlags(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_additionalFlags(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialSpeed(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialSpeed(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialSpeedRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialSpeedRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialYaw(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialYaw(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialPitch(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialPitch(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialHorizontal(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialHorizontal(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_initialVertical(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_initialVertical(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_lifetime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_lifetime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_lifetimeRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_lifetimeRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_killRadius(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_killRadius(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_gravityX(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_gravityX(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_gravityY(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_gravityY(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_gravity(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_gravity(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationMidHoldTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorStart(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorStart(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorMid(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorMid(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorEnd(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorEnd(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_drag(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_drag(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_mass(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_mass(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_massRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_massRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_massSizeMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_massSizeMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_localForces(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_localForces(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_worldForces(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_worldForces(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_localForcesFallback(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_localForcesFallback(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_worldForcesFallback(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_worldForcesFallback(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_worldForcesMassMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_worldForcesMassMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_noiseAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_noiseAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_noiseFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_noiseFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_noiseCoherence(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_noiseCoherence(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_noiseEdge(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_noiseEdge(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_indexPlusLength(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_indexPlusLength(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_maxParticles(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_maxParticles(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_emissionRate(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_emissionRate(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_emitterShape(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_emitterShape(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_shapeOuter(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_shapeOuter(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_shapeInner(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_shapeInner(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_outerRadius(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_outerRadius(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_innerRadius(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_innerRadius(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_shapeRegions_count(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> usize;
        pub fn whiteout_m3_M3ParticleEmitter_resize_shapeRegions(
            self_: *mut whiteout_M3ParticleEmitter,
            count: usize,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_shapeRegions_data(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *const u32;
        pub fn whiteout_m3_M3ParticleEmitter_assign_shapeRegions(
            self_: *mut whiteout_M3ParticleEmitter,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_velocityType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_velocityType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeRandomAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeRandomAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationRandomAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationRandomAnimation(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorStartRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorStartRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorMidRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorMidRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorEndRandom(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorEndRandom(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaRandomEnable(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_squirtAmount(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefU16;
        pub fn whiteout_m3_M3ParticleEmitter_set_squirtAmount(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefU16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookStartInitIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookStartInitIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookStartStopIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookStartStopIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookEndInitIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookEndInitIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookEndStopIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u8;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookEndStopIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u8,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookMidTime(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookColumns(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookColumns(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookRows(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookRows(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookColumnFraction(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookColumnFraction(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flipbookRowFraction(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_flipbookRowFraction(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_bounce(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_bounce(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_friction(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_friction(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionSpawnIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionSpawnIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionSpawnMin(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionSpawnMin(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionSpawnMax(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionSpawnMax(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionSpawnChance(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionSpawnChance(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionSpawnEnergy(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionSpawnEnergy(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_collisionDieBounce(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_collisionDieBounce(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_instanceType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_instanceType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_tailLength(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_tailLength(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_instanceAngle(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3ParticleEmitter_set_instanceAngle(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_instanceDistance(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_instanceDistance(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_pitchType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_pitchType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_pitchAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_pitchAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_pitchFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_pitchFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_yawType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_yawType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_yawAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_yawAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_yawFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_yawFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_speedType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_speedType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_speedAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_speedAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_speedFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_speedFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_horizontalType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_horizontalType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_horizontalAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_horizontalAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_horizontalFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_horizontalFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_verticalType(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_verticalType(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_verticalAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_verticalAmplitude(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_verticalFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_verticalFrequency(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_particleVelocity(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_particleVelocity(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_phaseShift(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_phaseShift(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_flags(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_flags(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationFlags(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationFlags(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_colorSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_colorSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_sizeSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_sizeSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_rotationSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_rotationSmoothing(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_alphaThreshold(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_alphaThreshold(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_uvOffset(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector2f;
        pub fn whiteout_m3_M3ParticleEmitter_set_uvOffset(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector2f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_uvAngle(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_set_uvAngle(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_uvTiling(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefVector2f;
        pub fn whiteout_m3_M3ParticleEmitter_set_uvTiling(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefVector2f,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_splineLineData_count(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> usize;
        pub fn whiteout_m3_M3ParticleEmitter_resize_splineLineData(
            self_: *mut whiteout_M3ParticleEmitter,
            count: usize,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_splineLineData_at(
            self_: *mut whiteout_M3ParticleEmitter,
            index: usize,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ParticleEmitter_get_windMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_windMultiplier(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_lodReduce(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_lodReduce(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_lodCut(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitter_set_lodCut(
            self_: *mut whiteout_M3ParticleEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_lowerBound(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_lowerBound(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_upperBound(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_upperBound(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_trailLinkIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_trailLinkIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_trailChance(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_trailChance(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_trailEmissionRate(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitter_set_trailEmissionRate(
            self_: *mut whiteout_M3ParticleEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_splatProjectionIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_splatProjectionIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_splatChance(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_splatChance(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_copyIndices_count(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> usize;
        pub fn whiteout_m3_M3ParticleEmitter_resize_copyIndices(
            self_: *mut whiteout_M3ParticleEmitter,
            count: usize,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_copyIndices_data(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> *const u32;
        pub fn whiteout_m3_M3ParticleEmitter_assign_copyIndices(
            self_: *mut whiteout_M3ParticleEmitter,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_spawnRibbonOnBounceChance(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3ParticleEmitter_set_spawnRibbonOnBounceChance(
            self_: *mut whiteout_M3ParticleEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3ParticleEmitter_get_ribbonLinkIndex(
            self_: *mut whiteout_M3ParticleEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3ParticleEmitter_set_ribbonLinkIndex(
            self_: *mut whiteout_M3ParticleEmitter,
            value: i32,
        );
        // ParticleEmitterCopy
        pub fn whiteout_m3_M3ParticleEmitterCopy_new() -> *mut whiteout_M3ParticleEmitterCopy;
        pub fn whiteout_m3_M3ParticleEmitterCopy_delete(self_: *mut whiteout_M3ParticleEmitterCopy);
        pub fn whiteout_m3_M3ParticleEmitterCopy_get_emissionRate(
            self_: *mut whiteout_M3ParticleEmitterCopy,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ParticleEmitterCopy_set_emissionRate(
            self_: *mut whiteout_M3ParticleEmitterCopy,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ParticleEmitterCopy_get_squirtAmount(
            self_: *mut whiteout_M3ParticleEmitterCopy,
        ) -> *mut whiteout_M3AnimRefU16;
        pub fn whiteout_m3_M3ParticleEmitterCopy_set_squirtAmount(
            self_: *mut whiteout_M3ParticleEmitterCopy,
            value: *const whiteout_M3AnimRefU16,
        );
        pub fn whiteout_m3_M3ParticleEmitterCopy_get_boneIndex(
            self_: *mut whiteout_M3ParticleEmitterCopy,
        ) -> u32;
        pub fn whiteout_m3_M3ParticleEmitterCopy_set_boneIndex(
            self_: *mut whiteout_M3ParticleEmitterCopy,
            value: u32,
        );
        // SplineRibbon
        pub fn whiteout_m3_M3SplineRibbon_new() -> *mut whiteout_M3SplineRibbon;
        pub fn whiteout_m3_M3SplineRibbon_delete(self_: *mut whiteout_M3SplineRibbon);
        pub fn whiteout_m3_M3SplineRibbon_get_emissionOffset(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SplineRibbon_set_emissionOffset(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_emissionVector(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SplineRibbon_set_emissionVector(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocity(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocity(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_reserved(self_: *mut whiteout_M3SplineRibbon) -> u32;
        pub fn whiteout_m3_M3SplineRibbon_set_reserved(
            self_: *mut whiteout_M3SplineRibbon,
            value: u32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_boneIndex(self_: *mut whiteout_M3SplineRibbon)
            -> u32;
        pub fn whiteout_m3_M3SplineRibbon_set_boneIndex(
            self_: *mut whiteout_M3SplineRibbon,
            value: u32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityBaseFactor(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityBaseFactor(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityEndFactor(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityEndFactor(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_yawType(self_: *mut whiteout_M3SplineRibbon) -> u32;
        pub fn whiteout_m3_M3SplineRibbon_set_yawType(
            self_: *mut whiteout_M3SplineRibbon,
            value: u32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_yawAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_yawAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_yawFrequency(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_yawFrequency(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_pitchType(self_: *mut whiteout_M3SplineRibbon)
            -> u32;
        pub fn whiteout_m3_M3SplineRibbon_set_pitchType(
            self_: *mut whiteout_M3SplineRibbon,
            value: u32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_pitchAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_pitchAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_pitchFrequency(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_pitchFrequency(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityType(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> u32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityType(
            self_: *mut whiteout_M3SplineRibbon,
            value: u32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityAmplitude(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityFrequency(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityFrequency(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_yaw(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_yaw(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_pitch(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3SplineRibbon_set_pitch(
            self_: *mut whiteout_M3SplineRibbon,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_emissionVectorNormFactor(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> f32;
        pub fn whiteout_m3_M3SplineRibbon_set_emissionVectorNormFactor(
            self_: *mut whiteout_M3SplineRibbon,
            value: f32,
        );
        pub fn whiteout_m3_M3SplineRibbon_get_velocityNormFactor(
            self_: *mut whiteout_M3SplineRibbon,
        ) -> f32;
        pub fn whiteout_m3_M3SplineRibbon_set_velocityNormFactor(
            self_: *mut whiteout_M3SplineRibbon,
            value: f32,
        );
        // RibbonEmitter
        pub fn whiteout_m3_M3RibbonEmitter_new() -> *mut whiteout_M3RibbonEmitter;
        pub fn whiteout_m3_M3RibbonEmitter_delete(self_: *mut whiteout_M3RibbonEmitter);
        pub fn whiteout_m3_M3RibbonEmitter_get_boneIndex(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_boneIndex(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_boneIndexFallback(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_boneIndexFallback(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_materialIndex(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_materialIndex(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_additionalFlags(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3RibbonEmitter_set_additionalFlags(
            self_: *mut whiteout_M3RibbonEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialSpeed(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialSpeed(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialSpeedRandom(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialSpeedRandom(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialYaw(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialYaw(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialPitch(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialPitch(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialHorizontal(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialHorizontal(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_initialVertical(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_initialVertical(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_lifetime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_lifetime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_lifetimeRandom(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_lifetimeRandom(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_killRadius(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_killRadius(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_gravityX(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_gravityX(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_gravityY(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_gravityY(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_gravity(self_: *mut whiteout_M3RibbonEmitter)
            -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_gravity(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_alphaMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_alphaMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_rotationMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_rotationMidTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_alphaMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_alphaMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_rotationMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_rotationMidHoldTime(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeAnimation(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeAnimation(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_rotationAnimation(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3RibbonEmitter_set_rotationAnimation(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorStart(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorStart(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorMid(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorMid(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorEnd(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorEnd(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_drag(self_: *mut whiteout_M3RibbonEmitter) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_drag(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_mass(self_: *mut whiteout_M3RibbonEmitter) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_mass(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_massRandom(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_massRandom(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_massSizeMultiplier(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_massSizeMultiplier(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_localForces(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_localForces(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_worldForces(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_worldForces(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_localForcesFallback(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_localForcesFallback(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_worldForcesFallback(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u16;
        pub fn whiteout_m3_M3RibbonEmitter_set_worldForcesFallback(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u16,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_worldForcesMassMultiplier(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_worldForcesMassMultiplier(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_noiseAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_noiseAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_noiseFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_noiseFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_noiseCoherence(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_noiseCoherence(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_noiseEdge(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_noiseEdge(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_indexPlusLength(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_indexPlusLength(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_emitterShape(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_emitterShape(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_ribbonType(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3RibbonEmitter_set_ribbonType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_divisions(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_divisions(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_edges(self_: *mut whiteout_M3RibbonEmitter) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_edges(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_innerRadius(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_innerRadius(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_maxLength(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_maxLength(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_splineRibbons_count(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> usize;
        pub fn whiteout_m3_M3RibbonEmitter_resize_splineRibbons(
            self_: *mut whiteout_M3RibbonEmitter,
            count: usize,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_splineRibbons_at(
            self_: *mut whiteout_M3RibbonEmitter,
            index: usize,
        ) -> *mut whiteout_M3SplineRibbon;
        pub fn whiteout_m3_M3RibbonEmitter_get_active(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3RibbonEmitter_set_active(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_flags(self_: *mut whiteout_M3RibbonEmitter) -> i32;
        pub fn whiteout_m3_M3RibbonEmitter_set_flags(
            self_: *mut whiteout_M3RibbonEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeSmoothing(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeSmoothing(
            self_: *mut whiteout_M3RibbonEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_colorSmoothing(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> i32;
        pub fn whiteout_m3_M3RibbonEmitter_set_colorSmoothing(
            self_: *mut whiteout_M3RibbonEmitter,
            value: i32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_friction(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_friction(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_bounce(self_: *mut whiteout_M3RibbonEmitter) -> f32;
        pub fn whiteout_m3_M3RibbonEmitter_set_bounce(
            self_: *mut whiteout_M3RibbonEmitter,
            value: f32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_lodReduce(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_lodReduce(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_lodCut(self_: *mut whiteout_M3RibbonEmitter) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_lodCut(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_yawType(self_: *mut whiteout_M3RibbonEmitter)
            -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_yawType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_yawAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_yawAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_yawFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_yawFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_pitchType(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_pitchType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_pitchAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_pitchAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_pitchFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_pitchFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_speedType(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_speedType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_speedAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_speedAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_speedFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_speedFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeType(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_sizeFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_sizeFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_alphaType(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> u32;
        pub fn whiteout_m3_M3RibbonEmitter_set_alphaType(
            self_: *mut whiteout_M3RibbonEmitter,
            value: u32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_alphaAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_alphaAmplitude(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_alphaFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_alphaFrequency(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_particleVelocity(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_particleVelocity(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3RibbonEmitter_get_overlay(
            self_: *mut whiteout_M3RibbonEmitter,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3RibbonEmitter_set_overlay(
            self_: *mut whiteout_M3RibbonEmitter,
            value: *const whiteout_M3AnimRefF32,
        );
        // Projector
        pub fn whiteout_m3_M3Projector_new() -> *mut whiteout_M3Projector;
        pub fn whiteout_m3_M3Projector_delete(self_: *mut whiteout_M3Projector);
        pub fn whiteout_m3_M3Projector_get_projectionType(self_: *mut whiteout_M3Projector) -> i32;
        pub fn whiteout_m3_M3Projector_set_projectionType(
            self_: *mut whiteout_M3Projector,
            value: i32,
        );
        pub fn whiteout_m3_M3Projector_get_bone(self_: *mut whiteout_M3Projector) -> u32;
        pub fn whiteout_m3_M3Projector_set_bone(self_: *mut whiteout_M3Projector, value: u32);
        pub fn whiteout_m3_M3Projector_get_materialReferenceIndex(
            self_: *mut whiteout_M3Projector,
        ) -> u32;
        pub fn whiteout_m3_M3Projector_set_materialReferenceIndex(
            self_: *mut whiteout_M3Projector,
            value: u32,
        );
        pub fn whiteout_m3_M3Projector_get_offset(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3Projector_set_offset(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3Projector_get_pitch(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_pitch(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_yaw(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_yaw(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_roll(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_roll(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_fieldOfView(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_fieldOfView(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_aspectRatio(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_aspectRatio(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_near(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_near(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_far(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_far(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetZBottom(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetZBottom(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetZTop(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetZTop(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetXLeft(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetXLeft(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetXRight(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetXRight(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetYFront(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetYFront(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_boxOffsetYBack(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Projector_set_boxOffsetYBack(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Projector_get_falloff(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_falloff(self_: *mut whiteout_M3Projector, value: f32);
        pub fn whiteout_m3_M3Projector_get_alphaInit(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_alphaInit(self_: *mut whiteout_M3Projector, value: f32);
        pub fn whiteout_m3_M3Projector_get_alphaMid(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_alphaMid(self_: *mut whiteout_M3Projector, value: f32);
        pub fn whiteout_m3_M3Projector_get_alphaEnd(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_alphaEnd(self_: *mut whiteout_M3Projector, value: f32);
        pub fn whiteout_m3_M3Projector_get_lifetimeAttack(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeAttack(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_lifetimeAttackTo(
            self_: *mut whiteout_M3Projector,
        ) -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeAttackTo(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_lifetimeHold(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeHold(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_lifetimeHoldTo(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeHoldTo(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_lifetimeDecay(self_: *mut whiteout_M3Projector) -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeDecay(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_lifetimeDecayTo(self_: *mut whiteout_M3Projector)
            -> f32;
        pub fn whiteout_m3_M3Projector_set_lifetimeDecayTo(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_attenuationDistance(
            self_: *mut whiteout_M3Projector,
        ) -> f32;
        pub fn whiteout_m3_M3Projector_set_attenuationDistance(
            self_: *mut whiteout_M3Projector,
            value: f32,
        );
        pub fn whiteout_m3_M3Projector_get_active(
            self_: *mut whiteout_M3Projector,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3Projector_set_active(
            self_: *mut whiteout_M3Projector,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3Projector_get_layer(self_: *mut whiteout_M3Projector) -> u32;
        pub fn whiteout_m3_M3Projector_set_layer(self_: *mut whiteout_M3Projector, value: u32);
        pub fn whiteout_m3_M3Projector_get_lodReduce(self_: *mut whiteout_M3Projector) -> u32;
        pub fn whiteout_m3_M3Projector_set_lodReduce(self_: *mut whiteout_M3Projector, value: u32);
        pub fn whiteout_m3_M3Projector_get_lodCut(self_: *mut whiteout_M3Projector) -> u32;
        pub fn whiteout_m3_M3Projector_set_lodCut(self_: *mut whiteout_M3Projector, value: u32);
        pub fn whiteout_m3_M3Projector_get_flags(self_: *mut whiteout_M3Projector) -> i32;
        pub fn whiteout_m3_M3Projector_set_flags(self_: *mut whiteout_M3Projector, value: i32);
        // MaterialMap
        pub fn whiteout_m3_M3MaterialMap_new() -> *mut whiteout_M3MaterialMap;
        pub fn whiteout_m3_M3MaterialMap_delete(self_: *mut whiteout_M3MaterialMap);
        pub fn whiteout_m3_M3MaterialMap_get_materialType(
            self_: *mut whiteout_M3MaterialMap,
        ) -> i32;
        pub fn whiteout_m3_M3MaterialMap_set_materialType(
            self_: *mut whiteout_M3MaterialMap,
            value: i32,
        );
        pub fn whiteout_m3_M3MaterialMap_get_materialIndex(
            self_: *mut whiteout_M3MaterialMap,
        ) -> u32;
        pub fn whiteout_m3_M3MaterialMap_set_materialIndex(
            self_: *mut whiteout_M3MaterialMap,
            value: u32,
        );
        // TextureLayer
        pub fn whiteout_m3_M3TextureLayer_new() -> *mut whiteout_M3TextureLayer;
        pub fn whiteout_m3_M3TextureLayer_delete(self_: *mut whiteout_M3TextureLayer);
        pub fn whiteout_m3_M3TextureLayer_get_id(self_: *mut whiteout_M3TextureLayer) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_id(self_: *mut whiteout_M3TextureLayer, value: u32);
        pub fn whiteout_m3_M3TextureLayer_get_texturePath(
            self_: *mut whiteout_M3TextureLayer,
        ) -> RawCString;
        pub fn whiteout_m3_M3TextureLayer_set_texturePath(
            self_: *mut whiteout_M3TextureLayer,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3TextureLayer_get_color(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3TextureLayer_set_color(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3TextureLayer_get_flags(self_: *mut whiteout_M3TextureLayer) -> i32;
        pub fn whiteout_m3_M3TextureLayer_set_flags(
            self_: *mut whiteout_M3TextureLayer,
            value: i32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvMapping(self_: *mut whiteout_M3TextureLayer)
            -> i32;
        pub fn whiteout_m3_M3TextureLayer_set_uvMapping(
            self_: *mut whiteout_M3TextureLayer,
            value: i32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_colorType(self_: *mut whiteout_M3TextureLayer)
            -> i32;
        pub fn whiteout_m3_M3TextureLayer_set_colorType(
            self_: *mut whiteout_M3TextureLayer,
            value: i32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_rgbMultiply(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TextureLayer_set_rgbMultiply(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_rgbAdd(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TextureLayer_set_rgbAdd(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_pocTexture(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_pocTexture(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_noiseAmplitude(
            self_: *mut whiteout_M3TextureLayer,
        ) -> f32;
        pub fn whiteout_m3_M3TextureLayer_set_noiseAmplitude(
            self_: *mut whiteout_M3TextureLayer,
            value: f32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_noiseFrequency(
            self_: *mut whiteout_M3TextureLayer,
        ) -> f32;
        pub fn whiteout_m3_M3TextureLayer_set_noiseFrequency(
            self_: *mut whiteout_M3TextureLayer,
            value: f32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_textureSource(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_textureSource(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviFrameRate(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_aviFrameRate(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviStart(self_: *mut whiteout_M3TextureLayer) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_aviStart(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviStop(self_: *mut whiteout_M3TextureLayer) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_aviStop(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviLoop(self_: *mut whiteout_M3TextureLayer) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_aviLoop(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviSync(self_: *mut whiteout_M3TextureLayer) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_aviSync(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviPlay(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3TextureLayer_set_aviPlay(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_aviRestart(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3TextureLayer_set_aviRestart(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_flipbookRows(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_flipbookRows(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_flipbookColumns(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_flipbookColumns(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_currentFrame(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefU16;
        pub fn whiteout_m3_M3TextureLayer_set_currentFrame(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefU16,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvOffset(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefVector2f;
        pub fn whiteout_m3_M3TextureLayer_set_uvOffset(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefVector2f,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvAngle(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3TextureLayer_set_uvAngle(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvTiling(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefVector2f;
        pub fn whiteout_m3_M3TextureLayer_set_uvTiling(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefVector2f,
        );
        pub fn whiteout_m3_M3TextureLayer_get_wOffset(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TextureLayer_set_wOffset(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_wTiling(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TextureLayer_set_wTiling(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_mapAlpha(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TextureLayer_set_mapAlpha(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_triplanarOffset(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3TextureLayer_set_triplanarOffset(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3TextureLayer_get_triplanarScale(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3TextureLayer_set_triplanarScale(
            self_: *mut whiteout_M3TextureLayer,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvSourceRelated(
            self_: *mut whiteout_M3TextureLayer,
        ) -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_uvSourceRelated(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelMode(
            self_: *mut whiteout_M3TextureLayer,
        ) -> i32;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelMode(
            self_: *mut whiteout_M3TextureLayer,
            value: i32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelExponent(
            self_: *mut whiteout_M3TextureLayer,
        ) -> f32;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelExponent(
            self_: *mut whiteout_M3TextureLayer,
            value: f32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelMin(
            self_: *mut whiteout_M3TextureLayer,
        ) -> f32;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelMin(
            self_: *mut whiteout_M3TextureLayer,
            value: f32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelMax(
            self_: *mut whiteout_M3TextureLayer,
        ) -> f32;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelMax(
            self_: *mut whiteout_M3TextureLayer,
            value: f32,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelTranslation(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelTranslation(
            self_: *mut whiteout_M3TextureLayer,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelMask(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelMask(
            self_: *mut whiteout_M3TextureLayer,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3TextureLayer_get_fresnelRotation(
            self_: *mut whiteout_M3TextureLayer,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TextureLayer_set_fresnelRotation(
            self_: *mut whiteout_M3TextureLayer,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3TextureLayer_get_uvDensity(self_: *mut whiteout_M3TextureLayer)
            -> u32;
        pub fn whiteout_m3_M3TextureLayer_set_uvDensity(
            self_: *mut whiteout_M3TextureLayer,
            value: u32,
        );
        // StandardMaterial
        pub fn whiteout_m3_M3StandardMaterial_new() -> *mut whiteout_M3StandardMaterial;
        pub fn whiteout_m3_M3StandardMaterial_delete(self_: *mut whiteout_M3StandardMaterial);
        pub fn whiteout_m3_M3StandardMaterial_get_name(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3StandardMaterial_set_name(
            self_: *mut whiteout_M3StandardMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_additionalFlags(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_additionalFlags(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_flags(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_flags(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_blendMode(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_blendMode(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_priority(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_priority(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_rttChannels(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3StandardMaterial_set_rttChannels(
            self_: *mut whiteout_M3StandardMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_specularExponent(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_specularExponent(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_depthBlendFalloff(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_depthBlendFalloff(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_alphaTestThreshold(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3StandardMaterial_set_alphaTestThreshold(
            self_: *mut whiteout_M3StandardMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_hdrSpecularMultiplier(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_hdrSpecularMultiplier(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_hdrEmissiveMultiplier(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_hdrEmissiveMultiplier(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_hdrEnvironmentConstant(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_hdrEnvironmentConstant(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_hdrEnvironmentDiffuse(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_hdrEnvironmentDiffuse(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_hdrEnvironmentSpecular(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3StandardMaterial_set_hdrEnvironmentSpecular(
            self_: *mut whiteout_M3StandardMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_materialClass(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_materialClass(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_layerBlendMode(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_layerBlendMode(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_emissiveBlendMode1(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_emissiveBlendMode1(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_emissiveBlendMode2(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_emissiveBlendMode2(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_specularMode(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterial_set_specularMode(
            self_: *mut whiteout_M3StandardMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_parallaxHeight(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3StandardMaterial_set_parallaxHeight(
            self_: *mut whiteout_M3StandardMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_motionBlurAmount(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3StandardMaterial_set_motionBlurAmount(
            self_: *mut whiteout_M3StandardMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_normalBlendFactors_count(
            self_: *mut whiteout_M3StandardMaterial,
        ) -> usize;
        pub fn whiteout_m3_M3StandardMaterial_resize_normalBlendFactors(
            self_: *mut whiteout_M3StandardMaterial,
            count: usize,
        );
        pub fn whiteout_m3_M3StandardMaterial_get_normalBlendFactors_at(
            self_: *mut whiteout_M3StandardMaterial,
            index: usize,
        ) -> *mut whiteout_M3AnimRefF32;
        // DisplacementMaterial
        pub fn whiteout_m3_M3DisplacementMaterial_new() -> *mut whiteout_M3DisplacementMaterial;
        pub fn whiteout_m3_M3DisplacementMaterial_delete(
            self_: *mut whiteout_M3DisplacementMaterial,
        );
        pub fn whiteout_m3_M3DisplacementMaterial_get_name(
            self_: *mut whiteout_M3DisplacementMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3DisplacementMaterial_set_name(
            self_: *mut whiteout_M3DisplacementMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3DisplacementMaterial_get_unknown(
            self_: *mut whiteout_M3DisplacementMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DisplacementMaterial_set_unknown(
            self_: *mut whiteout_M3DisplacementMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DisplacementMaterial_get_strength(
            self_: *mut whiteout_M3DisplacementMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3DisplacementMaterial_set_strength(
            self_: *mut whiteout_M3DisplacementMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3DisplacementMaterial_get_priority(
            self_: *mut whiteout_M3DisplacementMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DisplacementMaterial_set_priority(
            self_: *mut whiteout_M3DisplacementMaterial,
            value: u32,
        );
        // CompositeSection
        pub fn whiteout_m3_M3CompositeSection_new() -> *mut whiteout_M3CompositeSection;
        pub fn whiteout_m3_M3CompositeSection_delete(self_: *mut whiteout_M3CompositeSection);
        pub fn whiteout_m3_M3CompositeSection_get_materialIndex(
            self_: *mut whiteout_M3CompositeSection,
        ) -> u32;
        pub fn whiteout_m3_M3CompositeSection_set_materialIndex(
            self_: *mut whiteout_M3CompositeSection,
            value: u32,
        );
        pub fn whiteout_m3_M3CompositeSection_get_mapMultiplier(
            self_: *mut whiteout_M3CompositeSection,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3CompositeSection_set_mapMultiplier(
            self_: *mut whiteout_M3CompositeSection,
            value: *const whiteout_M3AnimRefF32,
        );
        // CompositeMaterial
        pub fn whiteout_m3_M3CompositeMaterial_new() -> *mut whiteout_M3CompositeMaterial;
        pub fn whiteout_m3_M3CompositeMaterial_delete(self_: *mut whiteout_M3CompositeMaterial);
        pub fn whiteout_m3_M3CompositeMaterial_get_name(
            self_: *mut whiteout_M3CompositeMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3CompositeMaterial_set_name(
            self_: *mut whiteout_M3CompositeMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3CompositeMaterial_get_priority(
            self_: *mut whiteout_M3CompositeMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3CompositeMaterial_set_priority(
            self_: *mut whiteout_M3CompositeMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3CompositeMaterial_get_sections_count(
            self_: *mut whiteout_M3CompositeMaterial,
        ) -> usize;
        pub fn whiteout_m3_M3CompositeMaterial_resize_sections(
            self_: *mut whiteout_M3CompositeMaterial,
            count: usize,
        );
        pub fn whiteout_m3_M3CompositeMaterial_get_sections_at(
            self_: *mut whiteout_M3CompositeMaterial,
            index: usize,
        ) -> *mut whiteout_M3CompositeSection;
        // TerrainMaterial
        pub fn whiteout_m3_M3TerrainMaterial_new() -> *mut whiteout_M3TerrainMaterial;
        pub fn whiteout_m3_M3TerrainMaterial_delete(self_: *mut whiteout_M3TerrainMaterial);
        pub fn whiteout_m3_M3TerrainMaterial_get_name(
            self_: *mut whiteout_M3TerrainMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3TerrainMaterial_set_name(
            self_: *mut whiteout_M3TerrainMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3TerrainMaterial_get_unknown(
            self_: *mut whiteout_M3TerrainMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3TerrainMaterial_set_unknown(
            self_: *mut whiteout_M3TerrainMaterial,
            value: u32,
        );
        // VolumeMaterial
        pub fn whiteout_m3_M3VolumeMaterial_new() -> *mut whiteout_M3VolumeMaterial;
        pub fn whiteout_m3_M3VolumeMaterial_delete(self_: *mut whiteout_M3VolumeMaterial);
        pub fn whiteout_m3_M3VolumeMaterial_get_name(
            self_: *mut whiteout_M3VolumeMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3VolumeMaterial_set_name(
            self_: *mut whiteout_M3VolumeMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3VolumeMaterial_get_blendMode(
            self_: *mut whiteout_M3VolumeMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3VolumeMaterial_set_blendMode(
            self_: *mut whiteout_M3VolumeMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3VolumeMaterial_get_falloffType(
            self_: *mut whiteout_M3VolumeMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3VolumeMaterial_set_falloffType(
            self_: *mut whiteout_M3VolumeMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3VolumeMaterial_get_density(
            self_: *mut whiteout_M3VolumeMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3VolumeMaterial_set_density(
            self_: *mut whiteout_M3VolumeMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3VolumeMaterial_get_alphaThreshold(
            self_: *mut whiteout_M3VolumeMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3VolumeMaterial_set_alphaThreshold(
            self_: *mut whiteout_M3VolumeMaterial,
            value: u32,
        );
        // HairMaterial
        pub fn whiteout_m3_M3HairMaterial_new() -> *mut whiteout_M3HairMaterial;
        pub fn whiteout_m3_M3HairMaterial_delete(self_: *mut whiteout_M3HairMaterial);
        pub fn whiteout_m3_M3HairMaterial_get_name(
            self_: *mut whiteout_M3HairMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3HairMaterial_set_name(
            self_: *mut whiteout_M3HairMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3HairMaterial_get_shiftPrimary(
            self_: *mut whiteout_M3HairMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3HairMaterial_set_shiftPrimary(
            self_: *mut whiteout_M3HairMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3HairMaterial_get_shiftSecondary(
            self_: *mut whiteout_M3HairMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3HairMaterial_set_shiftSecondary(
            self_: *mut whiteout_M3HairMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3HairMaterial_get_colorDiffuse(
            self_: *mut whiteout_M3HairMaterial,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3HairMaterial_set_colorDiffuse(
            self_: *mut whiteout_M3HairMaterial,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3HairMaterial_get_colorSpec(
            self_: *mut whiteout_M3HairMaterial,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3HairMaterial_set_colorSpec(
            self_: *mut whiteout_M3HairMaterial,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3HairMaterial_get_specExponent0(
            self_: *mut whiteout_M3HairMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3HairMaterial_set_specExponent0(
            self_: *mut whiteout_M3HairMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3HairMaterial_get_specExponent1(
            self_: *mut whiteout_M3HairMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3HairMaterial_set_specExponent1(
            self_: *mut whiteout_M3HairMaterial,
            value: f32,
        );
        // VolumeNoiseMaterial
        pub fn whiteout_m3_M3VolumeNoiseMaterial_new() -> *mut whiteout_M3VolumeNoiseMaterial;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_delete(self_: *mut whiteout_M3VolumeNoiseMaterial);
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_name(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_name(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_falloffType(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_falloffType(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_drawTransparency(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_drawTransparency(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_density(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_density(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_nearPlane(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_nearPlane(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_falloff(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_falloff(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_scrollRate(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_scrollRate(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_position(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_position(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_scale(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_scale(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_rotation(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_rotation(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_alphaThreshold(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_alphaThreshold(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3VolumeNoiseMaterial_get_flags(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3VolumeNoiseMaterial_set_flags(
            self_: *mut whiteout_M3VolumeNoiseMaterial,
            value: i32,
        );
        // CreepMaterial
        pub fn whiteout_m3_M3CreepMaterial_new() -> *mut whiteout_M3CreepMaterial;
        pub fn whiteout_m3_M3CreepMaterial_delete(self_: *mut whiteout_M3CreepMaterial);
        pub fn whiteout_m3_M3CreepMaterial_get_name(
            self_: *mut whiteout_M3CreepMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3CreepMaterial_set_name(
            self_: *mut whiteout_M3CreepMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3CreepMaterial_get_creepLow(
            self_: *mut whiteout_M3CreepMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3CreepMaterial_set_creepLow(
            self_: *mut whiteout_M3CreepMaterial,
            value: u32,
        );
        // STBMaterial
        pub fn whiteout_m3_M3STBMaterial_new() -> *mut whiteout_M3STBMaterial;
        pub fn whiteout_m3_M3STBMaterial_delete(self_: *mut whiteout_M3STBMaterial);
        pub fn whiteout_m3_M3STBMaterial_get_name(self_: *mut whiteout_M3STBMaterial)
            -> RawCString;
        pub fn whiteout_m3_M3STBMaterial_set_name(
            self_: *mut whiteout_M3STBMaterial,
            value: *const core::ffi::c_char,
        );
        // ReflectionMaterial
        pub fn whiteout_m3_M3ReflectionMaterial_new() -> *mut whiteout_M3ReflectionMaterial;
        pub fn whiteout_m3_M3ReflectionMaterial_delete(self_: *mut whiteout_M3ReflectionMaterial);
        pub fn whiteout_m3_M3ReflectionMaterial_get_name(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3ReflectionMaterial_set_name(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_unknown(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_unknown(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_reflectionStrength(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_reflectionStrength(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_displacementStrength(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_displacementStrength(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_reflectionOffset(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_reflectionOffset(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_blurAngle(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_blurAngle(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_blurDistanceMax(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_blurDistanceMax(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_flags(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_flags(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3ReflectionMaterial_get_unknown2(
            self_: *mut whiteout_M3ReflectionMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3ReflectionMaterial_set_unknown2(
            self_: *mut whiteout_M3ReflectionMaterial,
            value: u32,
        );
        // SubFlare
        pub fn whiteout_m3_M3SubFlare_new() -> *mut whiteout_M3SubFlare;
        pub fn whiteout_m3_M3SubFlare_delete(self_: *mut whiteout_M3SubFlare);
        pub fn whiteout_m3_M3SubFlare_get_index(self_: *mut whiteout_M3SubFlare) -> u32;
        pub fn whiteout_m3_M3SubFlare_set_index(self_: *mut whiteout_M3SubFlare, value: u32);
        pub fn whiteout_m3_M3SubFlare_get_position(self_: *mut whiteout_M3SubFlare) -> f32;
        pub fn whiteout_m3_M3SubFlare_set_position(self_: *mut whiteout_M3SubFlare, value: f32);
        pub fn whiteout_m3_M3SubFlare_get_sizeXY(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SubFlare_set_sizeXY(
            self_: *mut whiteout_M3SubFlare,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SubFlare_get_scaleXY(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SubFlare_set_scaleXY(
            self_: *mut whiteout_M3SubFlare,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SubFlare_get_fadeIn(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SubFlare_set_fadeIn(
            self_: *mut whiteout_M3SubFlare,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SubFlare_get_fadeOut(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SubFlare_set_fadeOut(
            self_: *mut whiteout_M3SubFlare,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3SubFlare_get_colorAlpha(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut whiteout_M3ColorBGRA;
        pub fn whiteout_m3_M3SubFlare_set_colorAlpha(
            self_: *mut whiteout_M3SubFlare,
            value: *const whiteout_M3ColorBGRA,
        );
        pub fn whiteout_m3_M3SubFlare_get_faceCenter(self_: *mut whiteout_M3SubFlare) -> u32;
        pub fn whiteout_m3_M3SubFlare_set_faceCenter(self_: *mut whiteout_M3SubFlare, value: u32);
        pub fn whiteout_m3_M3SubFlare_get_offset(
            self_: *mut whiteout_M3SubFlare,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3SubFlare_set_offset(
            self_: *mut whiteout_M3SubFlare,
            value: *const core::ffi::c_void,
        );
        // LensFlare
        pub fn whiteout_m3_M3LensFlare_new() -> *mut whiteout_M3LensFlare;
        pub fn whiteout_m3_M3LensFlare_delete(self_: *mut whiteout_M3LensFlare);
        pub fn whiteout_m3_M3LensFlare_get_name(self_: *mut whiteout_M3LensFlare) -> RawCString;
        pub fn whiteout_m3_M3LensFlare_set_name(
            self_: *mut whiteout_M3LensFlare,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3LensFlare_get_subFlares_count(
            self_: *mut whiteout_M3LensFlare,
        ) -> usize;
        pub fn whiteout_m3_M3LensFlare_resize_subFlares(
            self_: *mut whiteout_M3LensFlare,
            count: usize,
        );
        pub fn whiteout_m3_M3LensFlare_get_subFlares_at(
            self_: *mut whiteout_M3LensFlare,
            index: usize,
        ) -> *mut whiteout_M3SubFlare;
        pub fn whiteout_m3_M3LensFlare_get_columns(self_: *mut whiteout_M3LensFlare) -> u32;
        pub fn whiteout_m3_M3LensFlare_set_columns(self_: *mut whiteout_M3LensFlare, value: u32);
        pub fn whiteout_m3_M3LensFlare_get_rows(self_: *mut whiteout_M3LensFlare) -> u32;
        pub fn whiteout_m3_M3LensFlare_set_rows(self_: *mut whiteout_M3LensFlare, value: u32);
        pub fn whiteout_m3_M3LensFlare_get_distanceFade(self_: *mut whiteout_M3LensFlare) -> f32;
        pub fn whiteout_m3_M3LensFlare_set_distanceFade(
            self_: *mut whiteout_M3LensFlare,
            value: f32,
        );
        pub fn whiteout_m3_M3LensFlare_get_libName(self_: *mut whiteout_M3LensFlare) -> RawCString;
        pub fn whiteout_m3_M3LensFlare_set_libName(
            self_: *mut whiteout_M3LensFlare,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3LensFlare_get_intensity(
            self_: *mut whiteout_M3LensFlare,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3LensFlare_set_intensity(
            self_: *mut whiteout_M3LensFlare,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3LensFlare_get_color(
            self_: *mut whiteout_M3LensFlare,
        ) -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3LensFlare_set_color(
            self_: *mut whiteout_M3LensFlare,
            value: *const whiteout_M3AnimRefM3ColorBGRA,
        );
        pub fn whiteout_m3_M3LensFlare_get_hdr(
            self_: *mut whiteout_M3LensFlare,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3LensFlare_set_hdr(
            self_: *mut whiteout_M3LensFlare,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3LensFlare_get_size(
            self_: *mut whiteout_M3LensFlare,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3LensFlare_set_size(
            self_: *mut whiteout_M3LensFlare,
            value: *const whiteout_M3AnimRefF32,
        );
        // DataDrivenProperty
        pub fn whiteout_m3_M3DataDrivenProperty_new() -> *mut whiteout_M3DataDrivenProperty;
        pub fn whiteout_m3_M3DataDrivenProperty_delete(self_: *mut whiteout_M3DataDrivenProperty);
        pub fn whiteout_m3_M3DataDrivenProperty_get_nameHash(
            self_: *mut whiteout_M3DataDrivenProperty,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenProperty_set_nameHash(
            self_: *mut whiteout_M3DataDrivenProperty,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenProperty_get_name(
            self_: *mut whiteout_M3DataDrivenProperty,
        ) -> RawCString;
        pub fn whiteout_m3_M3DataDrivenProperty_set_name(
            self_: *mut whiteout_M3DataDrivenProperty,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3DataDrivenProperty_get_data_count(
            self_: *mut whiteout_M3DataDrivenProperty,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenProperty_resize_data(
            self_: *mut whiteout_M3DataDrivenProperty,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenProperty_get_data_data(
            self_: *mut whiteout_M3DataDrivenProperty,
        ) -> *const u8;
        pub fn whiteout_m3_M3DataDrivenProperty_assign_data(
            self_: *mut whiteout_M3DataDrivenProperty,
            data: *const u8,
            count: usize,
        );
        // DataDrivenGroup
        pub fn whiteout_m3_M3DataDrivenGroup_new() -> *mut whiteout_M3DataDrivenGroup;
        pub fn whiteout_m3_M3DataDrivenGroup_delete(self_: *mut whiteout_M3DataDrivenGroup);
        pub fn whiteout_m3_M3DataDrivenGroup_get_nameHash(
            self_: *mut whiteout_M3DataDrivenGroup,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenGroup_set_nameHash(
            self_: *mut whiteout_M3DataDrivenGroup,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenGroup_get_name(
            self_: *mut whiteout_M3DataDrivenGroup,
        ) -> RawCString;
        pub fn whiteout_m3_M3DataDrivenGroup_set_name(
            self_: *mut whiteout_M3DataDrivenGroup,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3DataDrivenGroup_get_properties_count(
            self_: *mut whiteout_M3DataDrivenGroup,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenGroup_resize_properties(
            self_: *mut whiteout_M3DataDrivenGroup,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenGroup_get_properties_at(
            self_: *mut whiteout_M3DataDrivenGroup,
            index: usize,
        ) -> *mut whiteout_M3DataDrivenProperty;
        // DataDrivenProperties
        pub fn whiteout_m3_M3DataDrivenProperties_new() -> *mut whiteout_M3DataDrivenProperties;
        pub fn whiteout_m3_M3DataDrivenProperties_delete(
            self_: *mut whiteout_M3DataDrivenProperties,
        );
        pub fn whiteout_m3_M3DataDrivenProperties_get_groups_count(
            self_: *mut whiteout_M3DataDrivenProperties,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenProperties_resize_groups(
            self_: *mut whiteout_M3DataDrivenProperties,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenProperties_get_groups_at(
            self_: *mut whiteout_M3DataDrivenProperties,
            index: usize,
        ) -> *mut whiteout_M3DataDrivenGroup;
        // StandardMaterialConversion
        pub fn whiteout_m3_M3StandardMaterialConversion_new(
        ) -> *mut whiteout_M3StandardMaterialConversion;
        pub fn whiteout_m3_M3StandardMaterialConversion_delete(
            self_: *mut whiteout_M3StandardMaterialConversion,
        );
        pub fn whiteout_m3_M3StandardMaterialConversion_get_converted(
            self_: *mut whiteout_M3StandardMaterialConversion,
        ) -> i32;
        pub fn whiteout_m3_M3StandardMaterialConversion_set_converted(
            self_: *mut whiteout_M3StandardMaterialConversion,
            value: i32,
        );
        pub fn whiteout_m3_M3StandardMaterialConversion_get_blocker(
            self_: *mut whiteout_M3StandardMaterialConversion,
        ) -> RawCString;
        pub fn whiteout_m3_M3StandardMaterialConversion_set_blocker(
            self_: *mut whiteout_M3StandardMaterialConversion,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3StandardMaterialConversion_get_material(
            self_: *mut whiteout_M3StandardMaterialConversion,
        ) -> *mut whiteout_M3StandardMaterial;
        pub fn whiteout_m3_M3StandardMaterialConversion_set_material(
            self_: *mut whiteout_M3StandardMaterialConversion,
            value: *const whiteout_M3StandardMaterial,
        );
        // DataDrivenMaterial
        pub fn whiteout_m3_M3DataDrivenMaterial_new() -> *mut whiteout_M3DataDrivenMaterial;
        pub fn whiteout_m3_M3DataDrivenMaterial_delete(self_: *mut whiteout_M3DataDrivenMaterial);
        pub fn whiteout_m3_M3DataDrivenMaterial_get_materialName(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> RawCString;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_materialName(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_count(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenMaterial_resize_fragmentHashes(
            self_: *mut whiteout_M3DataDrivenMaterial,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_fragmentHashes_data(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *const u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_assign_fragmentHashes(
            self_: *mut whiteout_M3DataDrivenMaterial,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_extraHashes_count(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenMaterial_resize_extraHashes(
            self_: *mut whiteout_M3DataDrivenMaterial,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_extraHashes_data(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *const u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_assign_extraHashes(
            self_: *mut whiteout_M3DataDrivenMaterial,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_count(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> usize;
        pub fn whiteout_m3_M3DataDrivenMaterial_resize_propertyBlob(
            self_: *mut whiteout_M3DataDrivenMaterial,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_propertyBlob_data(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *const u8;
        pub fn whiteout_m3_M3DataDrivenMaterial_assign_propertyBlob(
            self_: *mut whiteout_M3DataDrivenMaterial,
            data: *const u8,
            count: usize,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown108(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown108(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown112(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown112(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown116(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> f32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown116(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: f32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_effectNameHash(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_effectNameHash(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown124(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown124(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_padding128(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_padding128(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown132(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown132(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown136(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown136(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown140(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown140(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown144(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown144(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown148(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u8;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown148(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u8,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_alphaFresnelFlags(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u8;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_alphaFresnelFlags(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u8,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_shaderType(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_shaderType(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: i32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_unknown151(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u8;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_unknown151(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u8,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_effectNameHash2(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_effectNameHash2(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_get_effectNameHash3(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> u32;
        pub fn whiteout_m3_M3DataDrivenMaterial_set_effectNameHash3(
            self_: *mut whiteout_M3DataDrivenMaterial,
            value: u32,
        );
        pub fn whiteout_m3_M3DataDrivenMaterial_decodeProperties(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *mut whiteout_M3DataDrivenProperties;
        pub fn whiteout_m3_M3DataDrivenMaterial_toStandardMaterial(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *mut whiteout_M3StandardMaterialConversion;
        pub fn whiteout_m3_M3DataDrivenMaterial_approximateStandardMaterial(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> *mut whiteout_M3StandardMaterialConversion;
        pub fn whiteout_m3_M3DataDrivenMaterial_getVersion(
            self_: *mut whiteout_M3DataDrivenMaterial,
        ) -> i32;
        pub fn whiteout_m3_M3DataDrivenMaterial_setVersion(
            self_: *mut whiteout_M3DataDrivenMaterial,
            new_version: i32,
        ) -> i32;
        pub fn whiteout_m3_M3DataDrivenMaterial_forceVersion(
            self_: *mut whiteout_M3DataDrivenMaterial,
            new_version: i32,
        );
        // Bone
        pub fn whiteout_m3_M3Bone_new() -> *mut whiteout_M3Bone;
        pub fn whiteout_m3_M3Bone_delete(self_: *mut whiteout_M3Bone);
        pub fn whiteout_m3_M3Bone_get_unknown(self_: *mut whiteout_M3Bone) -> u32;
        pub fn whiteout_m3_M3Bone_set_unknown(self_: *mut whiteout_M3Bone, value: u32);
        pub fn whiteout_m3_M3Bone_get_name(self_: *mut whiteout_M3Bone) -> RawCString;
        pub fn whiteout_m3_M3Bone_set_name(
            self_: *mut whiteout_M3Bone,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Bone_get_flags(self_: *mut whiteout_M3Bone) -> i32;
        pub fn whiteout_m3_M3Bone_set_flags(self_: *mut whiteout_M3Bone, value: i32);
        pub fn whiteout_m3_M3Bone_get_parentIndex(self_: *mut whiteout_M3Bone) -> u16;
        pub fn whiteout_m3_M3Bone_set_parentIndex(self_: *mut whiteout_M3Bone, value: u16);
        pub fn whiteout_m3_M3Bone_get_padding(self_: *mut whiteout_M3Bone) -> u16;
        pub fn whiteout_m3_M3Bone_set_padding(self_: *mut whiteout_M3Bone, value: u16);
        pub fn whiteout_m3_M3Bone_get_position(
            self_: *mut whiteout_M3Bone,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3Bone_set_position(
            self_: *mut whiteout_M3Bone,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3Bone_get_rotation(
            self_: *mut whiteout_M3Bone,
        ) -> *mut whiteout_M3AnimRefQuaternion;
        pub fn whiteout_m3_M3Bone_set_rotation(
            self_: *mut whiteout_M3Bone,
            value: *const whiteout_M3AnimRefQuaternion,
        );
        pub fn whiteout_m3_M3Bone_get_scale(
            self_: *mut whiteout_M3Bone,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3Bone_set_scale(
            self_: *mut whiteout_M3Bone,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3Bone_get_visibility(
            self_: *mut whiteout_M3Bone,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3Bone_set_visibility(
            self_: *mut whiteout_M3Bone,
            value: *const whiteout_M3AnimRefU32,
        );
        // Region
        pub fn whiteout_m3_M3Region_new() -> *mut whiteout_M3Region;
        pub fn whiteout_m3_M3Region_delete(self_: *mut whiteout_M3Region);
        pub fn whiteout_m3_M3Region_get_index(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_index(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_unknown(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_unknown(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_firstVertex(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_firstVertex(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_vertexCount(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_vertexCount(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_firstIndex(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_firstIndex(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_indexCount(self_: *mut whiteout_M3Region) -> u32;
        pub fn whiteout_m3_M3Region_set_indexCount(self_: *mut whiteout_M3Region, value: u32);
        pub fn whiteout_m3_M3Region_get_unknown2(self_: *mut whiteout_M3Region) -> u16;
        pub fn whiteout_m3_M3Region_set_unknown2(self_: *mut whiteout_M3Region, value: u16);
        pub fn whiteout_m3_M3Region_get_firstBoneLookup(self_: *mut whiteout_M3Region) -> u16;
        pub fn whiteout_m3_M3Region_set_firstBoneLookup(self_: *mut whiteout_M3Region, value: u16);
        pub fn whiteout_m3_M3Region_get_boneLookupCount(self_: *mut whiteout_M3Region) -> u16;
        pub fn whiteout_m3_M3Region_set_boneLookupCount(self_: *mut whiteout_M3Region, value: u16);
        pub fn whiteout_m3_M3Region_get_padding(self_: *mut whiteout_M3Region) -> u16;
        pub fn whiteout_m3_M3Region_set_padding(self_: *mut whiteout_M3Region, value: u16);
        pub fn whiteout_m3_M3Region_get_boneWeightPairs(self_: *mut whiteout_M3Region) -> u8;
        pub fn whiteout_m3_M3Region_set_boneWeightPairs(self_: *mut whiteout_M3Region, value: u8);
        pub fn whiteout_m3_M3Region_get_boneIndexPairs(self_: *mut whiteout_M3Region) -> u8;
        pub fn whiteout_m3_M3Region_set_boneIndexPairs(self_: *mut whiteout_M3Region, value: u8);
        pub fn whiteout_m3_M3Region_get_rootBone(self_: *mut whiteout_M3Region) -> u16;
        pub fn whiteout_m3_M3Region_set_rootBone(self_: *mut whiteout_M3Region, value: u16);
        pub fn whiteout_m3_M3Region_get_flags(self_: *mut whiteout_M3Region) -> i32;
        pub fn whiteout_m3_M3Region_set_flags(self_: *mut whiteout_M3Region, value: i32);
        pub fn whiteout_m3_M3Region_get_uvScale(self_: *mut whiteout_M3Region) -> f32;
        pub fn whiteout_m3_M3Region_set_uvScale(self_: *mut whiteout_M3Region, value: f32);
        pub fn whiteout_m3_M3Region_get_uvOffset(self_: *mut whiteout_M3Region) -> f32;
        pub fn whiteout_m3_M3Region_set_uvOffset(self_: *mut whiteout_M3Region, value: f32);
        // Batch
        pub fn whiteout_m3_M3Batch_new() -> *mut whiteout_M3Batch;
        pub fn whiteout_m3_M3Batch_delete(self_: *mut whiteout_M3Batch);
        pub fn whiteout_m3_M3Batch_get_unknown(self_: *mut whiteout_M3Batch) -> u32;
        pub fn whiteout_m3_M3Batch_set_unknown(self_: *mut whiteout_M3Batch, value: u32);
        pub fn whiteout_m3_M3Batch_get_regionIndex(self_: *mut whiteout_M3Batch) -> u16;
        pub fn whiteout_m3_M3Batch_set_regionIndex(self_: *mut whiteout_M3Batch, value: u16);
        pub fn whiteout_m3_M3Batch_get_unknown2(self_: *mut whiteout_M3Batch) -> u32;
        pub fn whiteout_m3_M3Batch_set_unknown2(self_: *mut whiteout_M3Batch, value: u32);
        pub fn whiteout_m3_M3Batch_get_materialIndex(self_: *mut whiteout_M3Batch) -> u16;
        pub fn whiteout_m3_M3Batch_set_materialIndex(self_: *mut whiteout_M3Batch, value: u16);
        pub fn whiteout_m3_M3Batch_get_boneCount(self_: *mut whiteout_M3Batch) -> u16;
        pub fn whiteout_m3_M3Batch_set_boneCount(self_: *mut whiteout_M3Batch, value: u16);
        // MeshSection
        pub fn whiteout_m3_M3MeshSection_new() -> *mut whiteout_M3MeshSection;
        pub fn whiteout_m3_M3MeshSection_delete(self_: *mut whiteout_M3MeshSection);
        pub fn whiteout_m3_M3MeshSection_get_nodeIndex(self_: *mut whiteout_M3MeshSection) -> u32;
        pub fn whiteout_m3_M3MeshSection_set_nodeIndex(
            self_: *mut whiteout_M3MeshSection,
            value: u32,
        );
        pub fn whiteout_m3_M3MeshSection_get_bounds(
            self_: *mut whiteout_M3MeshSection,
        ) -> *mut whiteout_M3AnimRefM3Extent;
        pub fn whiteout_m3_M3MeshSection_set_bounds(
            self_: *mut whiteout_M3MeshSection,
            value: *const whiteout_M3AnimRefM3Extent,
        );
        // MeshDivision
        pub fn whiteout_m3_M3MeshDivision_new() -> *mut whiteout_M3MeshDivision;
        pub fn whiteout_m3_M3MeshDivision_delete(self_: *mut whiteout_M3MeshDivision);
        pub fn whiteout_m3_M3MeshDivision_get_faces_count(
            self_: *mut whiteout_M3MeshDivision,
        ) -> usize;
        pub fn whiteout_m3_M3MeshDivision_resize_faces(
            self_: *mut whiteout_M3MeshDivision,
            count: usize,
        );
        pub fn whiteout_m3_M3MeshDivision_get_faces_data(
            self_: *mut whiteout_M3MeshDivision,
        ) -> *const u16;
        pub fn whiteout_m3_M3MeshDivision_assign_faces(
            self_: *mut whiteout_M3MeshDivision,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3MeshDivision_get_regions_count(
            self_: *mut whiteout_M3MeshDivision,
        ) -> usize;
        pub fn whiteout_m3_M3MeshDivision_resize_regions(
            self_: *mut whiteout_M3MeshDivision,
            count: usize,
        );
        pub fn whiteout_m3_M3MeshDivision_get_regions_at(
            self_: *mut whiteout_M3MeshDivision,
            index: usize,
        ) -> *mut whiteout_M3Region;
        pub fn whiteout_m3_M3MeshDivision_get_batches_count(
            self_: *mut whiteout_M3MeshDivision,
        ) -> usize;
        pub fn whiteout_m3_M3MeshDivision_resize_batches(
            self_: *mut whiteout_M3MeshDivision,
            count: usize,
        );
        pub fn whiteout_m3_M3MeshDivision_get_batches_at(
            self_: *mut whiteout_M3MeshDivision,
            index: usize,
        ) -> *mut whiteout_M3Batch;
        pub fn whiteout_m3_M3MeshDivision_get_msec_count(
            self_: *mut whiteout_M3MeshDivision,
        ) -> usize;
        pub fn whiteout_m3_M3MeshDivision_resize_msec(
            self_: *mut whiteout_M3MeshDivision,
            count: usize,
        );
        pub fn whiteout_m3_M3MeshDivision_get_msec_at(
            self_: *mut whiteout_M3MeshDivision,
            index: usize,
        ) -> *mut whiteout_M3MeshSection;
        pub fn whiteout_m3_M3MeshDivision_get_instances(self_: *mut whiteout_M3MeshDivision)
            -> u32;
        pub fn whiteout_m3_M3MeshDivision_set_instances(
            self_: *mut whiteout_M3MeshDivision,
            value: u32,
        );
        // InitialReference
        pub fn whiteout_m3_M3InitialReference_new() -> *mut whiteout_M3InitialReference;
        pub fn whiteout_m3_M3InitialReference_delete(self_: *mut whiteout_M3InitialReference);
        // AttachmentPoint
        pub fn whiteout_m3_M3AttachmentPoint_new() -> *mut whiteout_M3AttachmentPoint;
        pub fn whiteout_m3_M3AttachmentPoint_delete(self_: *mut whiteout_M3AttachmentPoint);
        pub fn whiteout_m3_M3AttachmentPoint_get_unknown(
            self_: *mut whiteout_M3AttachmentPoint,
        ) -> u32;
        pub fn whiteout_m3_M3AttachmentPoint_set_unknown(
            self_: *mut whiteout_M3AttachmentPoint,
            value: u32,
        );
        pub fn whiteout_m3_M3AttachmentPoint_get_name(
            self_: *mut whiteout_M3AttachmentPoint,
        ) -> RawCString;
        pub fn whiteout_m3_M3AttachmentPoint_set_name(
            self_: *mut whiteout_M3AttachmentPoint,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3AttachmentPoint_get_boneIndex(
            self_: *mut whiteout_M3AttachmentPoint,
        ) -> u32;
        pub fn whiteout_m3_M3AttachmentPoint_set_boneIndex(
            self_: *mut whiteout_M3AttachmentPoint,
            value: u32,
        );
        // HitTestShape
        pub fn whiteout_m3_M3HitTestShape_new() -> *mut whiteout_M3HitTestShape;
        pub fn whiteout_m3_M3HitTestShape_delete(self_: *mut whiteout_M3HitTestShape);
        pub fn whiteout_m3_M3HitTestShape_get_shapeType(self_: *mut whiteout_M3HitTestShape)
            -> i32;
        pub fn whiteout_m3_M3HitTestShape_set_shapeType(
            self_: *mut whiteout_M3HitTestShape,
            value: i32,
        );
        pub fn whiteout_m3_M3HitTestShape_get_boneIndex(self_: *mut whiteout_M3HitTestShape)
            -> u16;
        pub fn whiteout_m3_M3HitTestShape_set_boneIndex(
            self_: *mut whiteout_M3HitTestShape,
            value: u16,
        );
        pub fn whiteout_m3_M3HitTestShape_get_padding(self_: *mut whiteout_M3HitTestShape) -> u16;
        pub fn whiteout_m3_M3HitTestShape_set_padding(
            self_: *mut whiteout_M3HitTestShape,
            value: u16,
        );
        pub fn whiteout_m3_M3HitTestShape_get_vertexPositions_count(
            self_: *mut whiteout_M3HitTestShape,
        ) -> usize;
        pub fn whiteout_m3_M3HitTestShape_resize_vertexPositions(
            self_: *mut whiteout_M3HitTestShape,
            count: usize,
        );
        pub fn whiteout_m3_M3HitTestShape_get_vertexPositions_data(
            self_: *mut whiteout_M3HitTestShape,
        ) -> *const f32;
        pub fn whiteout_m3_M3HitTestShape_assign_vertexPositions(
            self_: *mut whiteout_M3HitTestShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3HitTestShape_get_faceIndices_count(
            self_: *mut whiteout_M3HitTestShape,
        ) -> usize;
        pub fn whiteout_m3_M3HitTestShape_resize_faceIndices(
            self_: *mut whiteout_M3HitTestShape,
            count: usize,
        );
        pub fn whiteout_m3_M3HitTestShape_get_faceIndices_data(
            self_: *mut whiteout_M3HitTestShape,
        ) -> *const u16;
        pub fn whiteout_m3_M3HitTestShape_assign_faceIndices(
            self_: *mut whiteout_M3HitTestShape,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3HitTestShape_get_sizeX(self_: *mut whiteout_M3HitTestShape) -> f32;
        pub fn whiteout_m3_M3HitTestShape_set_sizeX(
            self_: *mut whiteout_M3HitTestShape,
            value: f32,
        );
        pub fn whiteout_m3_M3HitTestShape_get_sizeY(self_: *mut whiteout_M3HitTestShape) -> f32;
        pub fn whiteout_m3_M3HitTestShape_set_sizeY(
            self_: *mut whiteout_M3HitTestShape,
            value: f32,
        );
        pub fn whiteout_m3_M3HitTestShape_get_sizeZ(self_: *mut whiteout_M3HitTestShape) -> f32;
        pub fn whiteout_m3_M3HitTestShape_set_sizeZ(
            self_: *mut whiteout_M3HitTestShape,
            value: f32,
        );
        // AttachmentVolume
        pub fn whiteout_m3_M3AttachmentVolume_new() -> *mut whiteout_M3AttachmentVolume;
        pub fn whiteout_m3_M3AttachmentVolume_delete(self_: *mut whiteout_M3AttachmentVolume);
        pub fn whiteout_m3_M3AttachmentVolume_get_bone1(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> u32;
        pub fn whiteout_m3_M3AttachmentVolume_set_bone1(
            self_: *mut whiteout_M3AttachmentVolume,
            value: u32,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_bone2(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> u32;
        pub fn whiteout_m3_M3AttachmentVolume_set_bone2(
            self_: *mut whiteout_M3AttachmentVolume,
            value: u32,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_shapeType(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> i32;
        pub fn whiteout_m3_M3AttachmentVolume_set_shapeType(
            self_: *mut whiteout_M3AttachmentVolume,
            value: i32,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_boneIndex(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> u16;
        pub fn whiteout_m3_M3AttachmentVolume_set_boneIndex(
            self_: *mut whiteout_M3AttachmentVolume,
            value: u16,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_padding(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> u16;
        pub fn whiteout_m3_M3AttachmentVolume_set_padding(
            self_: *mut whiteout_M3AttachmentVolume,
            value: u16,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_vertexPositions_count(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> usize;
        pub fn whiteout_m3_M3AttachmentVolume_resize_vertexPositions(
            self_: *mut whiteout_M3AttachmentVolume,
            count: usize,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_vertexPositions_data(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> *const f32;
        pub fn whiteout_m3_M3AttachmentVolume_assign_vertexPositions(
            self_: *mut whiteout_M3AttachmentVolume,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_faceIndices_count(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> usize;
        pub fn whiteout_m3_M3AttachmentVolume_resize_faceIndices(
            self_: *mut whiteout_M3AttachmentVolume,
            count: usize,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_faceIndices_data(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> *const u16;
        pub fn whiteout_m3_M3AttachmentVolume_assign_faceIndices(
            self_: *mut whiteout_M3AttachmentVolume,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_sizeX(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> f32;
        pub fn whiteout_m3_M3AttachmentVolume_set_sizeX(
            self_: *mut whiteout_M3AttachmentVolume,
            value: f32,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_sizeY(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> f32;
        pub fn whiteout_m3_M3AttachmentVolume_set_sizeY(
            self_: *mut whiteout_M3AttachmentVolume,
            value: f32,
        );
        pub fn whiteout_m3_M3AttachmentVolume_get_sizeZ(
            self_: *mut whiteout_M3AttachmentVolume,
        ) -> f32;
        pub fn whiteout_m3_M3AttachmentVolume_set_sizeZ(
            self_: *mut whiteout_M3AttachmentVolume,
            value: f32,
        );
        // TriggerData
        pub fn whiteout_m3_M3TriggerData_new() -> *mut whiteout_M3TriggerData;
        pub fn whiteout_m3_M3TriggerData_delete(self_: *mut whiteout_M3TriggerData);
        pub fn whiteout_m3_M3TriggerData_get_dataIndices_count(
            self_: *mut whiteout_M3TriggerData,
        ) -> usize;
        pub fn whiteout_m3_M3TriggerData_resize_dataIndices(
            self_: *mut whiteout_M3TriggerData,
            count: usize,
        );
        pub fn whiteout_m3_M3TriggerData_get_dataIndices_data(
            self_: *mut whiteout_M3TriggerData,
        ) -> *const u32;
        pub fn whiteout_m3_M3TriggerData_assign_dataIndices(
            self_: *mut whiteout_M3TriggerData,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3TriggerData_get_name(self_: *mut whiteout_M3TriggerData)
            -> RawCString;
        pub fn whiteout_m3_M3TriggerData_set_name(
            self_: *mut whiteout_M3TriggerData,
            value: *const core::ffi::c_char,
        );
        // TurretBehavior
        pub fn whiteout_m3_M3TurretBehavior_new() -> *mut whiteout_M3TurretBehavior;
        pub fn whiteout_m3_M3TurretBehavior_delete(self_: *mut whiteout_M3TurretBehavior);
        pub fn whiteout_m3_M3TurretBehavior_get_unknown1(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TurretBehavior_set_unknown1(
            self_: *mut whiteout_M3TurretBehavior,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_unknown2(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TurretBehavior_set_unknown2(
            self_: *mut whiteout_M3TurretBehavior,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_boneIndex(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> u16;
        pub fn whiteout_m3_M3TurretBehavior_set_boneIndex(
            self_: *mut whiteout_M3TurretBehavior,
            value: u16,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_useAsMainTurret(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> u8;
        pub fn whiteout_m3_M3TurretBehavior_set_useAsMainTurret(
            self_: *mut whiteout_M3TurretBehavior,
            value: u8,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_turretGroupId(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> u8;
        pub fn whiteout_m3_M3TurretBehavior_set_turretGroupId(
            self_: *mut whiteout_M3TurretBehavior,
            value: u8,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_yawLimited(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> u32;
        pub fn whiteout_m3_M3TurretBehavior_set_yawLimited(
            self_: *mut whiteout_M3TurretBehavior,
            value: u32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_yawMin(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_yawMin(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_yawMax(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_yawMax(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_yawWeight(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_yawWeight(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_pitchLimited(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> u32;
        pub fn whiteout_m3_M3TurretBehavior_set_pitchLimited(
            self_: *mut whiteout_M3TurretBehavior,
            value: u32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_pitchMin(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_pitchMin(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_pitchMax(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_pitchMax(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_pitchWeight(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_pitchWeight(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_unknown3(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_unknown3(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_unknown4(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> f32;
        pub fn whiteout_m3_M3TurretBehavior_set_unknown4(
            self_: *mut whiteout_M3TurretBehavior,
            value: f32,
        );
        pub fn whiteout_m3_M3TurretBehavior_get_mainBoneOffset(
            self_: *mut whiteout_M3TurretBehavior,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3TurretBehavior_set_mainBoneOffset(
            self_: *mut whiteout_M3TurretBehavior,
            value: *const core::ffi::c_void,
        );
        // BillboardBehavior
        pub fn whiteout_m3_M3BillboardBehavior_new() -> *mut whiteout_M3BillboardBehavior;
        pub fn whiteout_m3_M3BillboardBehavior_delete(self_: *mut whiteout_M3BillboardBehavior);
        pub fn whiteout_m3_M3BillboardBehavior_get_dependents_count(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> usize;
        pub fn whiteout_m3_M3BillboardBehavior_resize_dependents(
            self_: *mut whiteout_M3BillboardBehavior,
            count: usize,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_dependents_data(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> *const u16;
        pub fn whiteout_m3_M3BillboardBehavior_assign_dependents(
            self_: *mut whiteout_M3BillboardBehavior,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_boneIndex(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> u16;
        pub fn whiteout_m3_M3BillboardBehavior_set_boneIndex(
            self_: *mut whiteout_M3BillboardBehavior,
            value: u16,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_billboardType(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> u8;
        pub fn whiteout_m3_M3BillboardBehavior_set_billboardType(
            self_: *mut whiteout_M3BillboardBehavior,
            value: u8,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_cameraLookAt(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> u8;
        pub fn whiteout_m3_M3BillboardBehavior_set_cameraLookAt(
            self_: *mut whiteout_M3BillboardBehavior,
            value: u8,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_up(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3BillboardBehavior_set_up(
            self_: *mut whiteout_M3BillboardBehavior,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3BillboardBehavior_get_forward(
            self_: *mut whiteout_M3BillboardBehavior,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3BillboardBehavior_set_forward(
            self_: *mut whiteout_M3BillboardBehavior,
            value: *const core::ffi::c_void,
        );
        // IKJoint
        pub fn whiteout_m3_M3IKJoint_new() -> *mut whiteout_M3IKJoint;
        pub fn whiteout_m3_M3IKJoint_delete(self_: *mut whiteout_M3IKJoint);
        pub fn whiteout_m3_M3IKJoint_get_dependents_count(self_: *mut whiteout_M3IKJoint) -> usize;
        pub fn whiteout_m3_M3IKJoint_resize_dependents(
            self_: *mut whiteout_M3IKJoint,
            count: usize,
        );
        pub fn whiteout_m3_M3IKJoint_get_dependents_data(
            self_: *mut whiteout_M3IKJoint,
        ) -> *const u16;
        pub fn whiteout_m3_M3IKJoint_assign_dependents(
            self_: *mut whiteout_M3IKJoint,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3IKJoint_get_boneIndex1(self_: *mut whiteout_M3IKJoint) -> u16;
        pub fn whiteout_m3_M3IKJoint_set_boneIndex1(self_: *mut whiteout_M3IKJoint, value: u16);
        pub fn whiteout_m3_M3IKJoint_get_boneIndex2(self_: *mut whiteout_M3IKJoint) -> u16;
        pub fn whiteout_m3_M3IKJoint_set_boneIndex2(self_: *mut whiteout_M3IKJoint, value: u16);
        pub fn whiteout_m3_M3IKJoint_get_raycastUp(self_: *mut whiteout_M3IKJoint) -> f32;
        pub fn whiteout_m3_M3IKJoint_set_raycastUp(self_: *mut whiteout_M3IKJoint, value: f32);
        pub fn whiteout_m3_M3IKJoint_get_raycastDown(self_: *mut whiteout_M3IKJoint) -> f32;
        pub fn whiteout_m3_M3IKJoint_set_raycastDown(self_: *mut whiteout_M3IKJoint, value: f32);
        pub fn whiteout_m3_M3IKJoint_get_maxSpeed(self_: *mut whiteout_M3IKJoint) -> f32;
        pub fn whiteout_m3_M3IKJoint_set_maxSpeed(self_: *mut whiteout_M3IKJoint, value: f32);
        pub fn whiteout_m3_M3IKJoint_get_goalThreshold(self_: *mut whiteout_M3IKJoint) -> f32;
        pub fn whiteout_m3_M3IKJoint_set_goalThreshold(self_: *mut whiteout_M3IKJoint, value: f32);
        // IKTwoJoint
        pub fn whiteout_m3_M3IKTwoJoint_new() -> *mut whiteout_M3IKTwoJoint;
        pub fn whiteout_m3_M3IKTwoJoint_delete(self_: *mut whiteout_M3IKTwoJoint);
        pub fn whiteout_m3_M3IKTwoJoint_get_dependents_count(
            self_: *mut whiteout_M3IKTwoJoint,
        ) -> usize;
        pub fn whiteout_m3_M3IKTwoJoint_resize_dependents(
            self_: *mut whiteout_M3IKTwoJoint,
            count: usize,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_dependents_data(
            self_: *mut whiteout_M3IKTwoJoint,
        ) -> *const u16;
        pub fn whiteout_m3_M3IKTwoJoint_assign_dependents(
            self_: *mut whiteout_M3IKTwoJoint,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_boneBase(self_: *mut whiteout_M3IKTwoJoint) -> u16;
        pub fn whiteout_m3_M3IKTwoJoint_set_boneBase(self_: *mut whiteout_M3IKTwoJoint, value: u16);
        pub fn whiteout_m3_M3IKTwoJoint_get_boneTarget(self_: *mut whiteout_M3IKTwoJoint) -> u16;
        pub fn whiteout_m3_M3IKTwoJoint_set_boneTarget(
            self_: *mut whiteout_M3IKTwoJoint,
            value: u16,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_boneEnd(self_: *mut whiteout_M3IKTwoJoint) -> u16;
        pub fn whiteout_m3_M3IKTwoJoint_set_boneEnd(self_: *mut whiteout_M3IKTwoJoint, value: u16);
        pub fn whiteout_m3_M3IKTwoJoint_get_padding(self_: *mut whiteout_M3IKTwoJoint) -> u16;
        pub fn whiteout_m3_M3IKTwoJoint_set_padding(self_: *mut whiteout_M3IKTwoJoint, value: u16);
        pub fn whiteout_m3_M3IKTwoJoint_get_hingeAxis(
            self_: *mut whiteout_M3IKTwoJoint,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3IKTwoJoint_set_hingeAxis(
            self_: *mut whiteout_M3IKTwoJoint,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_maxAngleInner(self_: *mut whiteout_M3IKTwoJoint)
            -> f32;
        pub fn whiteout_m3_M3IKTwoJoint_set_maxAngleInner(
            self_: *mut whiteout_M3IKTwoJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_maxAngleOuter(self_: *mut whiteout_M3IKTwoJoint)
            -> f32;
        pub fn whiteout_m3_M3IKTwoJoint_set_maxAngleOuter(
            self_: *mut whiteout_M3IKTwoJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3IKTwoJoint_get_searchUp(self_: *mut whiteout_M3IKTwoJoint) -> f32;
        pub fn whiteout_m3_M3IKTwoJoint_set_searchUp(self_: *mut whiteout_M3IKTwoJoint, value: f32);
        pub fn whiteout_m3_M3IKTwoJoint_get_searchDown(self_: *mut whiteout_M3IKTwoJoint) -> f32;
        pub fn whiteout_m3_M3IKTwoJoint_set_searchDown(
            self_: *mut whiteout_M3IKTwoJoint,
            value: f32,
        );
        // IKCCD
        pub fn whiteout_m3_M3IKCCD_new() -> *mut whiteout_M3IKCCD;
        pub fn whiteout_m3_M3IKCCD_delete(self_: *mut whiteout_M3IKCCD);
        pub fn whiteout_m3_M3IKCCD_get_dependents_count(self_: *mut whiteout_M3IKCCD) -> usize;
        pub fn whiteout_m3_M3IKCCD_resize_dependents(self_: *mut whiteout_M3IKCCD, count: usize);
        pub fn whiteout_m3_M3IKCCD_get_dependents_data(self_: *mut whiteout_M3IKCCD) -> *const u16;
        pub fn whiteout_m3_M3IKCCD_assign_dependents(
            self_: *mut whiteout_M3IKCCD,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3IKCCD_get_boneBase(self_: *mut whiteout_M3IKCCD) -> u16;
        pub fn whiteout_m3_M3IKCCD_set_boneBase(self_: *mut whiteout_M3IKCCD, value: u16);
        pub fn whiteout_m3_M3IKCCD_get_boneTarget(self_: *mut whiteout_M3IKCCD) -> u16;
        pub fn whiteout_m3_M3IKCCD_set_boneTarget(self_: *mut whiteout_M3IKCCD, value: u16);
        pub fn whiteout_m3_M3IKCCD_get_searchUp(self_: *mut whiteout_M3IKCCD) -> f32;
        pub fn whiteout_m3_M3IKCCD_set_searchUp(self_: *mut whiteout_M3IKCCD, value: f32);
        pub fn whiteout_m3_M3IKCCD_get_searchDown(self_: *mut whiteout_M3IKCCD) -> f32;
        pub fn whiteout_m3_M3IKCCD_set_searchDown(self_: *mut whiteout_M3IKCCD, value: f32);
        // OneBoneSolver
        pub fn whiteout_m3_M3OneBoneSolver_new() -> *mut whiteout_M3OneBoneSolver;
        pub fn whiteout_m3_M3OneBoneSolver_delete(self_: *mut whiteout_M3OneBoneSolver);
        pub fn whiteout_m3_M3OneBoneSolver_get_dependents_count(
            self_: *mut whiteout_M3OneBoneSolver,
        ) -> usize;
        pub fn whiteout_m3_M3OneBoneSolver_resize_dependents(
            self_: *mut whiteout_M3OneBoneSolver,
            count: usize,
        );
        pub fn whiteout_m3_M3OneBoneSolver_get_dependents_data(
            self_: *mut whiteout_M3OneBoneSolver,
        ) -> *const u16;
        pub fn whiteout_m3_M3OneBoneSolver_assign_dependents(
            self_: *mut whiteout_M3OneBoneSolver,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3OneBoneSolver_get_bone(self_: *mut whiteout_M3OneBoneSolver) -> u16;
        pub fn whiteout_m3_M3OneBoneSolver_set_bone(
            self_: *mut whiteout_M3OneBoneSolver,
            value: u16,
        );
        pub fn whiteout_m3_M3OneBoneSolver_get_boneFallback(
            self_: *mut whiteout_M3OneBoneSolver,
        ) -> u16;
        pub fn whiteout_m3_M3OneBoneSolver_set_boneFallback(
            self_: *mut whiteout_M3OneBoneSolver,
            value: u16,
        );
        pub fn whiteout_m3_M3OneBoneSolver_get_maxAngle(
            self_: *mut whiteout_M3OneBoneSolver,
        ) -> f32;
        pub fn whiteout_m3_M3OneBoneSolver_set_maxAngle(
            self_: *mut whiteout_M3OneBoneSolver,
            value: f32,
        );
        // ShadowBox
        pub fn whiteout_m3_M3ShadowBox_new() -> *mut whiteout_M3ShadowBox;
        pub fn whiteout_m3_M3ShadowBox_delete(self_: *mut whiteout_M3ShadowBox);
        // ViewVolume
        pub fn whiteout_m3_M3ViewVolume_new() -> *mut whiteout_M3ViewVolume;
        pub fn whiteout_m3_M3ViewVolume_delete(self_: *mut whiteout_M3ViewVolume);
        pub fn whiteout_m3_M3ViewVolume_get_nodeIndex(self_: *mut whiteout_M3ViewVolume) -> u32;
        pub fn whiteout_m3_M3ViewVolume_set_nodeIndex(
            self_: *mut whiteout_M3ViewVolume,
            value: u32,
        );
        pub fn whiteout_m3_M3ViewVolume_get_size(
            self_: *mut whiteout_M3ViewVolume,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3ViewVolume_set_size(
            self_: *mut whiteout_M3ViewVolume,
            value: *const whiteout_M3AnimRefVector3f,
        );
        // TrailingModel
        pub fn whiteout_m3_M3TrailingModel_new() -> *mut whiteout_M3TrailingModel;
        pub fn whiteout_m3_M3TrailingModel_delete(self_: *mut whiteout_M3TrailingModel);
        pub fn whiteout_m3_M3TrailingModel_get_vectors_count(
            self_: *mut whiteout_M3TrailingModel,
        ) -> usize;
        pub fn whiteout_m3_M3TrailingModel_resize_vectors(
            self_: *mut whiteout_M3TrailingModel,
            count: usize,
        );
        pub fn whiteout_m3_M3TrailingModel_get_vectors_data(
            self_: *mut whiteout_M3TrailingModel,
        ) -> *const f32;
        pub fn whiteout_m3_M3TrailingModel_assign_vectors(
            self_: *mut whiteout_M3TrailingModel,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3TrailingModel_get_param0(self_: *mut whiteout_M3TrailingModel) -> f32;
        pub fn whiteout_m3_M3TrailingModel_set_param0(
            self_: *mut whiteout_M3TrailingModel,
            value: f32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_param1(self_: *mut whiteout_M3TrailingModel) -> f32;
        pub fn whiteout_m3_M3TrailingModel_set_param1(
            self_: *mut whiteout_M3TrailingModel,
            value: f32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_animFloat0(
            self_: *mut whiteout_M3TrailingModel,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TrailingModel_set_animFloat0(
            self_: *mut whiteout_M3TrailingModel,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_animFloat1(
            self_: *mut whiteout_M3TrailingModel,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3TrailingModel_set_animFloat1(
            self_: *mut whiteout_M3TrailingModel,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_flag(self_: *mut whiteout_M3TrailingModel) -> u32;
        pub fn whiteout_m3_M3TrailingModel_set_flag(
            self_: *mut whiteout_M3TrailingModel,
            value: u32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_reserved0(
            self_: *mut whiteout_M3TrailingModel,
        ) -> u32;
        pub fn whiteout_m3_M3TrailingModel_set_reserved0(
            self_: *mut whiteout_M3TrailingModel,
            value: u32,
        );
        pub fn whiteout_m3_M3TrailingModel_get_reserved1(
            self_: *mut whiteout_M3TrailingModel,
        ) -> u32;
        pub fn whiteout_m3_M3TrailingModel_set_reserved1(
            self_: *mut whiteout_M3TrailingModel,
            value: u32,
        );
        // Force
        pub fn whiteout_m3_M3Force_new() -> *mut whiteout_M3Force;
        pub fn whiteout_m3_M3Force_delete(self_: *mut whiteout_M3Force);
        pub fn whiteout_m3_M3Force_get_forceType(self_: *mut whiteout_M3Force) -> i32;
        pub fn whiteout_m3_M3Force_set_forceType(self_: *mut whiteout_M3Force, value: i32);
        pub fn whiteout_m3_M3Force_get_forceShape(self_: *mut whiteout_M3Force) -> i32;
        pub fn whiteout_m3_M3Force_set_forceShape(self_: *mut whiteout_M3Force, value: i32);
        pub fn whiteout_m3_M3Force_get_unknown(self_: *mut whiteout_M3Force) -> u32;
        pub fn whiteout_m3_M3Force_set_unknown(self_: *mut whiteout_M3Force, value: u32);
        pub fn whiteout_m3_M3Force_get_boneIndex(self_: *mut whiteout_M3Force) -> u32;
        pub fn whiteout_m3_M3Force_set_boneIndex(self_: *mut whiteout_M3Force, value: u32);
        pub fn whiteout_m3_M3Force_get_flags(self_: *mut whiteout_M3Force) -> i32;
        pub fn whiteout_m3_M3Force_set_flags(self_: *mut whiteout_M3Force, value: i32);
        pub fn whiteout_m3_M3Force_get_localChannels(self_: *mut whiteout_M3Force) -> u32;
        pub fn whiteout_m3_M3Force_set_localChannels(self_: *mut whiteout_M3Force, value: u32);
        pub fn whiteout_m3_M3Force_get_strength(
            self_: *mut whiteout_M3Force,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Force_set_strength(
            self_: *mut whiteout_M3Force,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Force_get_width(
            self_: *mut whiteout_M3Force,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Force_set_width(
            self_: *mut whiteout_M3Force,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Force_get_height(
            self_: *mut whiteout_M3Force,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Force_set_height(
            self_: *mut whiteout_M3Force,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Force_get_length(
            self_: *mut whiteout_M3Force,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Force_set_length(
            self_: *mut whiteout_M3Force,
            value: *const whiteout_M3AnimRefF32,
        );
        // Warp
        pub fn whiteout_m3_M3Warp_new() -> *mut whiteout_M3Warp;
        pub fn whiteout_m3_M3Warp_delete(self_: *mut whiteout_M3Warp);
        pub fn whiteout_m3_M3Warp_get_warpType(self_: *mut whiteout_M3Warp) -> u32;
        pub fn whiteout_m3_M3Warp_set_warpType(self_: *mut whiteout_M3Warp, value: u32);
        pub fn whiteout_m3_M3Warp_get_boneIndex(self_: *mut whiteout_M3Warp) -> u32;
        pub fn whiteout_m3_M3Warp_set_boneIndex(self_: *mut whiteout_M3Warp, value: u32);
        pub fn whiteout_m3_M3Warp_get_unknown(self_: *mut whiteout_M3Warp) -> u32;
        pub fn whiteout_m3_M3Warp_set_unknown(self_: *mut whiteout_M3Warp, value: u32);
        pub fn whiteout_m3_M3Warp_get_radius(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_radius(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Warp_get_height(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_height(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Warp_get_strength(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_strength(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Warp_get_angular(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_angular(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Warp_get_axial(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_axial(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Warp_get_radial(
            self_: *mut whiteout_M3Warp,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Warp_set_radial(
            self_: *mut whiteout_M3Warp,
            value: *const whiteout_M3AnimRefF32,
        );
        // ConvexHullHalfEdge
        pub fn whiteout_m3_M3ConvexHullHalfEdge_new() -> *mut whiteout_M3ConvexHullHalfEdge;
        pub fn whiteout_m3_M3ConvexHullHalfEdge_delete(self_: *mut whiteout_M3ConvexHullHalfEdge);
        pub fn whiteout_m3_M3ConvexHullHalfEdge_get_type(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
        ) -> u8;
        pub fn whiteout_m3_M3ConvexHullHalfEdge_set_type(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
            value: u8,
        );
        pub fn whiteout_m3_M3ConvexHullHalfEdge_get_faceIndex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
        ) -> u8;
        pub fn whiteout_m3_M3ConvexHullHalfEdge_set_faceIndex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
            value: u8,
        );
        pub fn whiteout_m3_M3ConvexHullHalfEdge_get_vertexIndex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
        ) -> u8;
        pub fn whiteout_m3_M3ConvexHullHalfEdge_set_vertexIndex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
            value: u8,
        );
        pub fn whiteout_m3_M3ConvexHullHalfEdge_get_nextAroundVertex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
        ) -> u8;
        pub fn whiteout_m3_M3ConvexHullHalfEdge_set_nextAroundVertex(
            self_: *mut whiteout_M3ConvexHullHalfEdge,
            value: u8,
        );
        // PhysicsMeshBvhNode
        pub fn whiteout_m3_M3PhysicsMeshBvhNode_new() -> *mut whiteout_M3PhysicsMeshBvhNode;
        pub fn whiteout_m3_M3PhysicsMeshBvhNode_delete(self_: *mut whiteout_M3PhysicsMeshBvhNode);
        // PhysicsMeshTriangle
        pub fn whiteout_m3_M3PhysicsMeshTriangle_new() -> *mut whiteout_M3PhysicsMeshTriangle;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_delete(self_: *mut whiteout_M3PhysicsMeshTriangle);
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex0(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex0(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex1(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex1(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_vertexIndex2(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_vertexIndex2(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex0(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex0(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex1(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex1(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_edgeIndex2(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_edgeIndex2(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_reserved(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u16;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_reserved(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u16,
        );
        pub fn whiteout_m3_M3PhysicsMeshTriangle_get_flags(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
        ) -> u16;
        pub fn whiteout_m3_M3PhysicsMeshTriangle_set_flags(
            self_: *mut whiteout_M3PhysicsMeshTriangle,
            value: u16,
        );
        // PhysicsMeshEdge
        pub fn whiteout_m3_M3PhysicsMeshEdge_new() -> *mut whiteout_M3PhysicsMeshEdge;
        pub fn whiteout_m3_M3PhysicsMeshEdge_delete(self_: *mut whiteout_M3PhysicsMeshEdge);
        pub fn whiteout_m3_M3PhysicsMeshEdge_get_edgeType(
            self_: *mut whiteout_M3PhysicsMeshEdge,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshEdge_set_edgeType(
            self_: *mut whiteout_M3PhysicsMeshEdge,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshEdge_get_vertexA(
            self_: *mut whiteout_M3PhysicsMeshEdge,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshEdge_set_vertexA(
            self_: *mut whiteout_M3PhysicsMeshEdge,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshEdge_get_vertexB(
            self_: *mut whiteout_M3PhysicsMeshEdge,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshEdge_set_vertexB(
            self_: *mut whiteout_M3PhysicsMeshEdge,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshEdge_get_faceA(
            self_: *mut whiteout_M3PhysicsMeshEdge,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshEdge_set_faceA(
            self_: *mut whiteout_M3PhysicsMeshEdge,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsMeshEdge_get_faceB(
            self_: *mut whiteout_M3PhysicsMeshEdge,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsMeshEdge_set_faceB(
            self_: *mut whiteout_M3PhysicsMeshEdge,
            value: u32,
        );
        // PhysicsShape
        pub fn whiteout_m3_M3PhysicsShape_new() -> *mut whiteout_M3PhysicsShape;
        pub fn whiteout_m3_M3PhysicsShape_delete(self_: *mut whiteout_M3PhysicsShape);
        pub fn whiteout_m3_M3PhysicsShape_get_collisionMargin(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsShape_set_collisionMargin(
            self_: *mut whiteout_M3PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_shapeType(self_: *mut whiteout_M3PhysicsShape)
            -> i32;
        pub fn whiteout_m3_M3PhysicsShape_set_shapeType(
            self_: *mut whiteout_M3PhysicsShape,
            value: i32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_oldSizes(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_oldSizes(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_shapeDimensions(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_shapeDimensions(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullFaceNormals_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_hullFaceNormals(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullFaceNormals_data(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *const f32;
        pub fn whiteout_m3_M3PhysicsShape_assign_hullFaceNormals(
            self_: *mut whiteout_M3PhysicsShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullVertexPositions_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_hullVertexPositions(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullVertexPositions_data(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *const f32;
        pub fn whiteout_m3_M3PhysicsShape_assign_hullVertexPositions(
            self_: *mut whiteout_M3PhysicsShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullHalfEdges_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_hullHalfEdges(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullHalfEdges_at(
            self_: *mut whiteout_M3PhysicsShape,
            index: usize,
        ) -> *mut whiteout_M3ConvexHullHalfEdge;
        pub fn whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_hullVertexFaceIndices(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullVertexFaceIndices_data(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *const u8;
        pub fn whiteout_m3_M3PhysicsShape_assign_hullVertexFaceIndices(
            self_: *mut whiteout_M3PhysicsShape,
            data: *const u8,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullCenter(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_hullCenter(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullFaceNormalCount(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_hullFaceNormalCount(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullVertexCount(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_hullVertexCount(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullHalfEdgeCount(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_hullHalfEdgeCount(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullUnknown0(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsShape_set_hullUnknown0(
            self_: *mut whiteout_M3PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_hullUnknown1(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsShape_set_hullUnknown1(
            self_: *mut whiteout_M3PhysicsShape,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshBvhNodes_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_meshBvhNodes(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshBvhNodes_at(
            self_: *mut whiteout_M3PhysicsShape,
            index: usize,
        ) -> *mut whiteout_M3PhysicsMeshBvhNode;
        pub fn whiteout_m3_M3PhysicsShape_get_meshVertexPositions_count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsShape_resize_meshVertexPositions(
            self_: *mut whiteout_M3PhysicsShape,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshVertexPositions_data(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *const f32;
        pub fn whiteout_m3_M3PhysicsShape_assign_meshVertexPositions(
            self_: *mut whiteout_M3PhysicsShape,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshBoundsCenter(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_meshBoundsCenter(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshBoundsExtent(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_meshBoundsExtent(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshTolerance(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3PhysicsShape_set_meshTolerance(
            self_: *mut whiteout_M3PhysicsShape,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshNormalCount(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshNormalCount(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshVertexCount(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshVertexCount(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshFaceIndex16Count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshFaceIndex16Count(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshFaceIndex32Count(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshFaceIndex32Count(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshUnknown1(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshUnknown1(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshReserved(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshReserved(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshTreeDepth(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshTreeDepth(
            self_: *mut whiteout_M3PhysicsShape,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsShape_get_meshCollisionMargin(
            self_: *mut whiteout_M3PhysicsShape,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsShape_set_meshCollisionMargin(
            self_: *mut whiteout_M3PhysicsShape,
            value: f32,
        );
        // RigidBody
        pub fn whiteout_m3_M3RigidBody_new() -> *mut whiteout_M3RigidBody;
        pub fn whiteout_m3_M3RigidBody_delete(self_: *mut whiteout_M3RigidBody);
        pub fn whiteout_m3_M3RigidBody_get_simulationType(self_: *mut whiteout_M3RigidBody) -> u16;
        pub fn whiteout_m3_M3RigidBody_set_simulationType(
            self_: *mut whiteout_M3RigidBody,
            value: u16,
        );
        pub fn whiteout_m3_M3RigidBody_get_parentBoneIndex(self_: *mut whiteout_M3RigidBody)
            -> u16;
        pub fn whiteout_m3_M3RigidBody_set_parentBoneIndex(
            self_: *mut whiteout_M3RigidBody,
            value: u16,
        );
        pub fn whiteout_m3_M3RigidBody_get_physicsType(self_: *mut whiteout_M3RigidBody) -> u32;
        pub fn whiteout_m3_M3RigidBody_set_physicsType(
            self_: *mut whiteout_M3RigidBody,
            value: u32,
        );
        pub fn whiteout_m3_M3RigidBody_get_density(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_density(self_: *mut whiteout_M3RigidBody, value: f32);
        pub fn whiteout_m3_M3RigidBody_get_friction(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_friction(self_: *mut whiteout_M3RigidBody, value: f32);
        pub fn whiteout_m3_M3RigidBody_get_restitution(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_restitution(
            self_: *mut whiteout_M3RigidBody,
            value: f32,
        );
        pub fn whiteout_m3_M3RigidBody_get_linearDamping(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_linearDamping(
            self_: *mut whiteout_M3RigidBody,
            value: f32,
        );
        pub fn whiteout_m3_M3RigidBody_get_angularDamping(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_angularDamping(
            self_: *mut whiteout_M3RigidBody,
            value: f32,
        );
        pub fn whiteout_m3_M3RigidBody_get_gravityScale(self_: *mut whiteout_M3RigidBody) -> f32;
        pub fn whiteout_m3_M3RigidBody_set_gravityScale(
            self_: *mut whiteout_M3RigidBody,
            value: f32,
        );
        pub fn whiteout_m3_M3RigidBody_get_dynamicState(
            self_: *mut whiteout_M3RigidBody,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3RigidBody_set_dynamicState(
            self_: *mut whiteout_M3RigidBody,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3RigidBody_get_dynamicBlendOut(self_: *mut whiteout_M3RigidBody)
            -> f32;
        pub fn whiteout_m3_M3RigidBody_set_dynamicBlendOut(
            self_: *mut whiteout_M3RigidBody,
            value: f32,
        );
        pub fn whiteout_m3_M3RigidBody_get_rigidBodyShape_count(
            self_: *mut whiteout_M3RigidBody,
        ) -> usize;
        pub fn whiteout_m3_M3RigidBody_resize_rigidBodyShape(
            self_: *mut whiteout_M3RigidBody,
            count: usize,
        );
        pub fn whiteout_m3_M3RigidBody_get_rigidBodyShape_at(
            self_: *mut whiteout_M3RigidBody,
            index: usize,
        ) -> *mut whiteout_M3PhysicsShape;
        pub fn whiteout_m3_M3RigidBody_get_flags(self_: *mut whiteout_M3RigidBody) -> i32;
        pub fn whiteout_m3_M3RigidBody_set_flags(self_: *mut whiteout_M3RigidBody, value: i32);
        pub fn whiteout_m3_M3RigidBody_get_localForces(self_: *mut whiteout_M3RigidBody) -> u16;
        pub fn whiteout_m3_M3RigidBody_set_localForces(
            self_: *mut whiteout_M3RigidBody,
            value: u16,
        );
        pub fn whiteout_m3_M3RigidBody_get_worldForces(self_: *mut whiteout_M3RigidBody) -> u16;
        pub fn whiteout_m3_M3RigidBody_set_worldForces(
            self_: *mut whiteout_M3RigidBody,
            value: u16,
        );
        pub fn whiteout_m3_M3RigidBody_get_priority(self_: *mut whiteout_M3RigidBody) -> u32;
        pub fn whiteout_m3_M3RigidBody_set_priority(self_: *mut whiteout_M3RigidBody, value: u32);
        // PhysicsJoint
        pub fn whiteout_m3_M3PhysicsJoint_new() -> *mut whiteout_M3PhysicsJoint;
        pub fn whiteout_m3_M3PhysicsJoint_delete(self_: *mut whiteout_M3PhysicsJoint);
        pub fn whiteout_m3_M3PhysicsJoint_get_jointType(self_: *mut whiteout_M3PhysicsJoint)
            -> u32;
        pub fn whiteout_m3_M3PhysicsJoint_set_jointType(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_boneIndex1(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsJoint_set_boneIndex1(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_boneIndex2(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsJoint_set_boneIndex2(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_enableLimits(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsJoint_set_enableLimits(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_limitMin(self_: *mut whiteout_M3PhysicsJoint) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_limitMin(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_limitMax(self_: *mut whiteout_M3PhysicsJoint) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_limitMax(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_coneAngle(self_: *mut whiteout_M3PhysicsJoint)
            -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_coneAngle(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_enableFriction(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> u32;
        pub fn whiteout_m3_M3PhysicsJoint_set_enableFriction(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_friction(self_: *mut whiteout_M3PhysicsJoint) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_friction(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_dampingRatio(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_dampingRatio(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_angularFrequency(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_angularFrequency(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_breakThreshold(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsJoint_set_breakThreshold(
            self_: *mut whiteout_M3PhysicsJoint,
            value: f32,
        );
        pub fn whiteout_m3_M3PhysicsJoint_get_enableShape(
            self_: *mut whiteout_M3PhysicsJoint,
        ) -> u8;
        pub fn whiteout_m3_M3PhysicsJoint_set_enableShape(
            self_: *mut whiteout_M3PhysicsJoint,
            value: u8,
        );
        // PhysicsConstraint
        pub fn whiteout_m3_M3PhysicsConstraint_new() -> *mut whiteout_M3PhysicsConstraint;
        pub fn whiteout_m3_M3PhysicsConstraint_delete(self_: *mut whiteout_M3PhysicsConstraint);
        pub fn whiteout_m3_M3PhysicsConstraint_get_dependents_count(
            self_: *mut whiteout_M3PhysicsConstraint,
        ) -> usize;
        pub fn whiteout_m3_M3PhysicsConstraint_resize_dependents(
            self_: *mut whiteout_M3PhysicsConstraint,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsConstraint_get_dependents_data(
            self_: *mut whiteout_M3PhysicsConstraint,
        ) -> *const u16;
        pub fn whiteout_m3_M3PhysicsConstraint_assign_dependents(
            self_: *mut whiteout_M3PhysicsConstraint,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3PhysicsConstraint_get_rigidBody1(
            self_: *mut whiteout_M3PhysicsConstraint,
        ) -> u16;
        pub fn whiteout_m3_M3PhysicsConstraint_set_rigidBody1(
            self_: *mut whiteout_M3PhysicsConstraint,
            value: u16,
        );
        pub fn whiteout_m3_M3PhysicsConstraint_get_rigidBody2(
            self_: *mut whiteout_M3PhysicsConstraint,
        ) -> u16;
        pub fn whiteout_m3_M3PhysicsConstraint_set_rigidBody2(
            self_: *mut whiteout_M3PhysicsConstraint,
            value: u16,
        );
        pub fn whiteout_m3_M3PhysicsConstraint_get_breakForce(
            self_: *mut whiteout_M3PhysicsConstraint,
        ) -> f32;
        pub fn whiteout_m3_M3PhysicsConstraint_set_breakForce(
            self_: *mut whiteout_M3PhysicsConstraint,
            value: f32,
        );
        // ClothCollider
        pub fn whiteout_m3_M3ClothCollider_new() -> *mut whiteout_M3ClothCollider;
        pub fn whiteout_m3_M3ClothCollider_delete(self_: *mut whiteout_M3ClothCollider);
        pub fn whiteout_m3_M3ClothCollider_get_radius(self_: *mut whiteout_M3ClothCollider) -> f32;
        pub fn whiteout_m3_M3ClothCollider_set_radius(
            self_: *mut whiteout_M3ClothCollider,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothCollider_get_height(self_: *mut whiteout_M3ClothCollider) -> f32;
        pub fn whiteout_m3_M3ClothCollider_set_height(
            self_: *mut whiteout_M3ClothCollider,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothCollider_get_padding(self_: *mut whiteout_M3ClothCollider)
            -> u32;
        pub fn whiteout_m3_M3ClothCollider_set_padding(
            self_: *mut whiteout_M3ClothCollider,
            value: u32,
        );
        // ClothProxy
        pub fn whiteout_m3_M3ClothProxy_new() -> *mut whiteout_M3ClothProxy;
        pub fn whiteout_m3_M3ClothProxy_delete(self_: *mut whiteout_M3ClothProxy);
        pub fn whiteout_m3_M3ClothProxy_get_proxyIndex(self_: *mut whiteout_M3ClothProxy) -> u32;
        pub fn whiteout_m3_M3ClothProxy_set_proxyIndex(
            self_: *mut whiteout_M3ClothProxy,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothProxy_get_clothIndex(self_: *mut whiteout_M3ClothProxy) -> u32;
        pub fn whiteout_m3_M3ClothProxy_set_clothIndex(
            self_: *mut whiteout_M3ClothProxy,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothProxy_get_proxyVertices_count(
            self_: *mut whiteout_M3ClothProxy,
        ) -> usize;
        pub fn whiteout_m3_M3ClothProxy_resize_proxyVertices(
            self_: *mut whiteout_M3ClothProxy,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothProxy_get_proxyVertices_data(
            self_: *mut whiteout_M3ClothProxy,
        ) -> *const u64;
        pub fn whiteout_m3_M3ClothProxy_assign_proxyVertices(
            self_: *mut whiteout_M3ClothProxy,
            data: *const u64,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothProxy_get_proxyWeights_count(
            self_: *mut whiteout_M3ClothProxy,
        ) -> usize;
        pub fn whiteout_m3_M3ClothProxy_resize_proxyWeights(
            self_: *mut whiteout_M3ClothProxy,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothProxy_get_proxyWeights_data(
            self_: *mut whiteout_M3ClothProxy,
        ) -> *const u32;
        pub fn whiteout_m3_M3ClothProxy_assign_proxyWeights(
            self_: *mut whiteout_M3ClothProxy,
            data: *const u32,
            count: usize,
        );
        // ClothPhysics
        pub fn whiteout_m3_M3ClothPhysics_new() -> *mut whiteout_M3ClothPhysics;
        pub fn whiteout_m3_M3ClothPhysics_delete(self_: *mut whiteout_M3ClothPhysics);
        pub fn whiteout_m3_M3ClothPhysics_get_clothMeshCount(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> u32;
        pub fn whiteout_m3_M3ClothPhysics_set_clothMeshCount(
            self_: *mut whiteout_M3ClothPhysics,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinBoneCount(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> u32;
        pub fn whiteout_m3_M3ClothPhysics_set_skinBoneCount(
            self_: *mut whiteout_M3ClothPhysics,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinBones_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_skinBones(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinBones_data(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *const u16;
        pub fn whiteout_m3_M3ClothPhysics_assign_skinBones(
            self_: *mut whiteout_M3ClothPhysics,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_simEnabled_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_simEnabled(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_simEnabled_data(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *const u8;
        pub fn whiteout_m3_M3ClothPhysics_assign_simEnabled(
            self_: *mut whiteout_M3ClothPhysics,
            data: *const u8,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_vertexBones_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_vertexBones(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_vertexBones_data(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *const u32;
        pub fn whiteout_m3_M3ClothPhysics_assign_vertexBones(
            self_: *mut whiteout_M3ClothPhysics,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_vertexWeights_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_vertexWeights(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_vertexWeights_data(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *const u32;
        pub fn whiteout_m3_M3ClothPhysics_assign_vertexWeights(
            self_: *mut whiteout_M3ClothPhysics,
            data: *const u32,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_colliders_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_colliders(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_colliders_at(
            self_: *mut whiteout_M3ClothPhysics,
            index: usize,
        ) -> *mut whiteout_M3ClothCollider;
        pub fn whiteout_m3_M3ClothPhysics_get_proxies_count(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> usize;
        pub fn whiteout_m3_M3ClothPhysics_resize_proxies(
            self_: *mut whiteout_M3ClothPhysics,
            count: usize,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_proxies_at(
            self_: *mut whiteout_M3ClothPhysics,
            index: usize,
        ) -> *mut whiteout_M3ClothProxy;
        pub fn whiteout_m3_M3ClothPhysics_get_density(self_: *mut whiteout_M3ClothPhysics) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_density(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_tracking(self_: *mut whiteout_M3ClothPhysics) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_tracking(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_stretchStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_stretchStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_horizontalStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_horizontalStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_bendingStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_bendingStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_damping(self_: *mut whiteout_M3ClothPhysics) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_damping(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_friction(self_: *mut whiteout_M3ClothPhysics) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_friction(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_gravity(self_: *mut whiteout_M3ClothPhysics) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_gravity(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_explosionScale(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_explosionScale(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_windScale(self_: *mut whiteout_M3ClothPhysics)
            -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_windScale(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_shearStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_shearStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_dragFactor(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_dragFactor(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_liftFactor(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_liftFactor(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_sphereStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_sphereStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_flatten(self_: *mut whiteout_M3ClothPhysics) -> u32;
        pub fn whiteout_m3_M3ClothPhysics_set_flatten(
            self_: *mut whiteout_M3ClothPhysics,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_active(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3ClothPhysics_set_active(
            self_: *mut whiteout_M3ClothPhysics,
            value: *const whiteout_M3AnimRefU32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_useSkinCollision(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> u32;
        pub fn whiteout_m3_M3ClothPhysics_set_useSkinCollision(
            self_: *mut whiteout_M3ClothPhysics,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinOffset(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_skinOffset(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinExponent(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_skinExponent(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_skinStiffness(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> f32;
        pub fn whiteout_m3_M3ClothPhysics_set_skinStiffness(
            self_: *mut whiteout_M3ClothPhysics,
            value: f32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_localChannels(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> u32;
        pub fn whiteout_m3_M3ClothPhysics_set_localChannels(
            self_: *mut whiteout_M3ClothPhysics,
            value: u32,
        );
        pub fn whiteout_m3_M3ClothPhysics_get_localWind(
            self_: *mut whiteout_M3ClothPhysics,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3ClothPhysics_set_localWind(
            self_: *mut whiteout_M3ClothPhysics,
            value: *const core::ffi::c_void,
        );
        // Light
        pub fn whiteout_m3_M3Light_new() -> *mut whiteout_M3Light;
        pub fn whiteout_m3_M3Light_delete(self_: *mut whiteout_M3Light);
        pub fn whiteout_m3_M3Light_get_lightType(self_: *mut whiteout_M3Light) -> i32;
        pub fn whiteout_m3_M3Light_set_lightType(self_: *mut whiteout_M3Light, value: i32);
        pub fn whiteout_m3_M3Light_get_boneIndex(self_: *mut whiteout_M3Light) -> u16;
        pub fn whiteout_m3_M3Light_set_boneIndex(self_: *mut whiteout_M3Light, value: u16);
        pub fn whiteout_m3_M3Light_get_flags(self_: *mut whiteout_M3Light) -> i32;
        pub fn whiteout_m3_M3Light_set_flags(self_: *mut whiteout_M3Light, value: i32);
        pub fn whiteout_m3_M3Light_get_lodCut(self_: *mut whiteout_M3Light) -> u32;
        pub fn whiteout_m3_M3Light_set_lodCut(self_: *mut whiteout_M3Light, value: u32);
        pub fn whiteout_m3_M3Light_get_shadowLodCut(self_: *mut whiteout_M3Light) -> u32;
        pub fn whiteout_m3_M3Light_set_shadowLodCut(self_: *mut whiteout_M3Light, value: u32);
        pub fn whiteout_m3_M3Light_get_diffuseColor(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3Light_set_diffuseColor(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3Light_get_intensityMultiplier(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_intensityMultiplier(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Light_get_specularColor(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3Light_set_specularColor(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefVector3f,
        );
        pub fn whiteout_m3_M3Light_get_specularMultiplier(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_specularMultiplier(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Light_get_decay(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_decay(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Light_get_attenuationEnd(self_: *mut whiteout_M3Light) -> f32;
        pub fn whiteout_m3_M3Light_set_attenuationEnd(self_: *mut whiteout_M3Light, value: f32);
        pub fn whiteout_m3_M3Light_get_attenuationStart(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_attenuationStart(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Light_get_hotSpot(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_hotSpot(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Light_get_falloff(
            self_: *mut whiteout_M3Light,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Light_set_falloff(
            self_: *mut whiteout_M3Light,
            value: *const whiteout_M3AnimRefF32,
        );
        // Camera
        pub fn whiteout_m3_M3Camera_new() -> *mut whiteout_M3Camera;
        pub fn whiteout_m3_M3Camera_delete(self_: *mut whiteout_M3Camera);
        pub fn whiteout_m3_M3Camera_get_boneIndex(self_: *mut whiteout_M3Camera) -> u32;
        pub fn whiteout_m3_M3Camera_set_boneIndex(self_: *mut whiteout_M3Camera, value: u32);
        pub fn whiteout_m3_M3Camera_get_name(self_: *mut whiteout_M3Camera) -> RawCString;
        pub fn whiteout_m3_M3Camera_set_name(
            self_: *mut whiteout_M3Camera,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Camera_get_fieldOfView(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_fieldOfView(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_useVerticalFOV(self_: *mut whiteout_M3Camera) -> u32;
        pub fn whiteout_m3_M3Camera_set_useVerticalFOV(self_: *mut whiteout_M3Camera, value: u32);
        pub fn whiteout_m3_M3Camera_get_dofType(self_: *mut whiteout_M3Camera) -> u32;
        pub fn whiteout_m3_M3Camera_set_dofType(self_: *mut whiteout_M3Camera, value: u32);
        pub fn whiteout_m3_M3Camera_get_farClip(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_farClip(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_nearClip(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_nearClip(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_shadowClipDistance(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_shadowClipDistance(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_focusDistance(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_focusDistance(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_farFocusRange(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_farFocusRange(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_nearFocusRange(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_nearFocusRange(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_nearFalloffStart(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_nearFalloffStart(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_nearFalloffEnd(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_nearFalloffEnd(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_dofAmount(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_dofAmount(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_bokehFStop(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_bokehFStop(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        pub fn whiteout_m3_M3Camera_get_bokehMaxCoCDiameter(
            self_: *mut whiteout_M3Camera,
        ) -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3Camera_set_bokehMaxCoCDiameter(
            self_: *mut whiteout_M3Camera,
            value: *const whiteout_M3AnimRefF32,
        );
        // Model
        pub fn whiteout_m3_M3Model_new() -> *mut whiteout_M3Model;
        pub fn whiteout_m3_M3Model_delete(self_: *mut whiteout_M3Model);
        pub fn whiteout_m3_M3Model_get_name(self_: *mut whiteout_M3Model) -> RawCString;
        pub fn whiteout_m3_M3Model_set_name(
            self_: *mut whiteout_M3Model,
            value: *const core::ffi::c_char,
        );
        pub fn whiteout_m3_M3Model_get_flags(self_: *mut whiteout_M3Model) -> i32;
        pub fn whiteout_m3_M3Model_set_flags(self_: *mut whiteout_M3Model, value: i32);
        pub fn whiteout_m3_M3Model_get_sequences_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_sequences(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_sequences_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Sequence;
        pub fn whiteout_m3_M3Model_get_subTrackCollections_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_subTrackCollections(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_subTrackCollections_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3SubTrackContainer;
        pub fn whiteout_m3_M3Model_get_animationGroups_count(self_: *mut whiteout_M3Model)
            -> usize;
        pub fn whiteout_m3_M3Model_resize_animationGroups(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_animationGroups_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3AnimationGroup;
        pub fn whiteout_m3_M3Model_get_boneAnimationSets_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_boneAnimationSets(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_boneAnimationSets_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3BoneAnimationSet;
        pub fn whiteout_m3_M3Model_get_animationSplitCount(self_: *mut whiteout_M3Model) -> u32;
        pub fn whiteout_m3_M3Model_set_animationSplitCount(
            self_: *mut whiteout_M3Model,
            value: u32,
        );
        pub fn whiteout_m3_M3Model_get_animationStates_count(self_: *mut whiteout_M3Model)
            -> usize;
        pub fn whiteout_m3_M3Model_resize_animationStates(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_animationStates_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3AnimationState;
        pub fn whiteout_m3_M3Model_get_bones_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_bones(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_bones_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Bone;
        pub fn whiteout_m3_M3Model_get_skinBoneCount(self_: *mut whiteout_M3Model) -> u32;
        pub fn whiteout_m3_M3Model_set_skinBoneCount(self_: *mut whiteout_M3Model, value: u32);
        pub fn whiteout_m3_M3Model_get_divisions_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_divisions(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_divisions_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3MeshDivision;
        pub fn whiteout_m3_M3Model_get_boneLookup_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_boneLookup(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_boneLookup_data(self_: *mut whiteout_M3Model) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_boneLookup(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_bounds(
            self_: *mut whiteout_M3Model,
        ) -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3Model_set_bounds(
            self_: *mut whiteout_M3Model,
            value: *const whiteout_M3Extent,
        );
        pub fn whiteout_m3_M3Model_get_collisionBounds(
            self_: *mut whiteout_M3Model,
        ) -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3Model_set_collisionBounds(
            self_: *mut whiteout_M3Model,
            value: *const whiteout_M3Extent,
        );
        pub fn whiteout_m3_M3Model_get_collisionFaces_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_collisionFaces(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_collisionFaces_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_collisionFaces(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_collisionVerts_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_collisionVerts(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_collisionVerts_data(
            self_: *mut whiteout_M3Model,
        ) -> *const f32;
        pub fn whiteout_m3_M3Model_assign_collisionVerts(
            self_: *mut whiteout_M3Model,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_collisionNormals_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_collisionNormals(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_collisionNormals_data(
            self_: *mut whiteout_M3Model,
        ) -> *const f32;
        pub fn whiteout_m3_M3Model_assign_collisionNormals(
            self_: *mut whiteout_M3Model,
            data: *const f32,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentPoints_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_attachmentPoints(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentPoints_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3AttachmentPoint;
        pub fn whiteout_m3_M3Model_get_attachmentPointAddons_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_attachmentPointAddons(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentPointAddons_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_attachmentPointAddons(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_lights_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_lights(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_lights_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Light;
        pub fn whiteout_m3_M3Model_get_shadowBoxes_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_shadowBoxes(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_shadowBoxes_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ShadowBox;
        pub fn whiteout_m3_M3Model_get_cameras_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_cameras(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_cameras_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Camera;
        pub fn whiteout_m3_M3Model_get_camerasAddons_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_camerasAddons(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_camerasAddons_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_camerasAddons(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_materialMaps_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_materialMaps(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_materialMaps_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3MaterialMap;
        pub fn whiteout_m3_M3Model_get_standardMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_standardMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_standardMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3StandardMaterial;
        pub fn whiteout_m3_M3Model_get_displacementMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_displacementMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_displacementMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3DisplacementMaterial;
        pub fn whiteout_m3_M3Model_get_compositeMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_compositeMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_compositeMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3CompositeMaterial;
        pub fn whiteout_m3_M3Model_get_terrainMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_terrainMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_terrainMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3TerrainMaterial;
        pub fn whiteout_m3_M3Model_get_volumeMaterials_count(self_: *mut whiteout_M3Model)
            -> usize;
        pub fn whiteout_m3_M3Model_resize_volumeMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_volumeMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3VolumeMaterial;
        pub fn whiteout_m3_M3Model_get_hairMaterials_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_hairMaterials(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_hairMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3HairMaterial;
        pub fn whiteout_m3_M3Model_get_creepMaterials_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_creepMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_creepMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3CreepMaterial;
        pub fn whiteout_m3_M3Model_get_volumeNoiseMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_volumeNoiseMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_volumeNoiseMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3VolumeNoiseMaterial;
        pub fn whiteout_m3_M3Model_get_stbMaterials_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_stbMaterials(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_stbMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3STBMaterial;
        pub fn whiteout_m3_M3Model_get_reflectionMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_reflectionMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_reflectionMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ReflectionMaterial;
        pub fn whiteout_m3_M3Model_get_lensFlareMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_lensFlareMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_lensFlareMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3LensFlare;
        pub fn whiteout_m3_M3Model_get_dataDrivenMaterials_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_dataDrivenMaterials(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_dataDrivenMaterials_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3DataDrivenMaterial;
        pub fn whiteout_m3_M3Model_get_particleEmitters_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_particleEmitters(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_particleEmitters_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ParticleEmitter;
        pub fn whiteout_m3_M3Model_get_particleEmitterCopies_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_particleEmitterCopies(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_particleEmitterCopies_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ParticleEmitterCopy;
        pub fn whiteout_m3_M3Model_get_ribbonEmitters_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_ribbonEmitters(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_ribbonEmitters_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3RibbonEmitter;
        pub fn whiteout_m3_M3Model_get_projections_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_projections(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_projections_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Projector;
        pub fn whiteout_m3_M3Model_get_forces_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_forces(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_forces_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Force;
        pub fn whiteout_m3_M3Model_get_warps_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_warps(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_warps_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3Warp;
        pub fn whiteout_m3_M3Model_get_viewVolumes_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_viewVolumes(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_viewVolumes_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ViewVolume;
        pub fn whiteout_m3_M3Model_get_rigidBodies_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_rigidBodies(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_rigidBodies_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3RigidBody;
        pub fn whiteout_m3_M3Model_get_physicsConstraints_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_physicsConstraints(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_physicsConstraints_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3PhysicsConstraint;
        pub fn whiteout_m3_M3Model_get_physicsJoints_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_physicsJoints(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_physicsJoints_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3PhysicsJoint;
        pub fn whiteout_m3_M3Model_get_clothPhysics_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_clothPhysics(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_clothPhysics_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3ClothPhysics;
        pub fn whiteout_m3_M3Model_get_ikTwoJoints_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_ikTwoJoints(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_ikTwoJoints_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3IKTwoJoint;
        pub fn whiteout_m3_M3Model_get_ikCCD_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_ikCCD(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_ikCCD_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3IKCCD;
        pub fn whiteout_m3_M3Model_get_ikJoints_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_ikJoints(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_ikJoints_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3IKJoint;
        pub fn whiteout_m3_M3Model_get_oneBoneSolvers_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_oneBoneSolvers(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_oneBoneSolvers_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3OneBoneSolver;
        pub fn whiteout_m3_M3Model_get_turretBehaviors_count(self_: *mut whiteout_M3Model)
            -> usize;
        pub fn whiteout_m3_M3Model_resize_turretBehaviors(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_turretBehaviors_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3TurretBehavior;
        pub fn whiteout_m3_M3Model_get_triggerData_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_triggerData(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_triggerData_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3TriggerData;
        pub fn whiteout_m3_M3Model_get_initialReference_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_initialReference(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_initialReference_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3InitialReference;
        pub fn whiteout_m3_M3Model_get_tightHitTestObject(
            self_: *mut whiteout_M3Model,
        ) -> *mut whiteout_M3HitTestShape;
        pub fn whiteout_m3_M3Model_set_tightHitTestObject(
            self_: *mut whiteout_M3Model,
            value: *const whiteout_M3HitTestShape,
        );
        pub fn whiteout_m3_M3Model_get_fuzzyHitTestObjects_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_fuzzyHitTestObjects(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_fuzzyHitTestObjects_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3HitTestShape;
        pub fn whiteout_m3_M3Model_get_attachmentVolumes_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_attachmentVolumes(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentVolumes_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3AttachmentVolume;
        pub fn whiteout_m3_M3Model_get_attachmentVolumesAddon0_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_attachmentVolumesAddon0(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentVolumesAddon0_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_attachmentVolumesAddon0(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentVolumesAddon1_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_attachmentVolumesAddon1(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_attachmentVolumesAddon1_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u16;
        pub fn whiteout_m3_M3Model_assign_attachmentVolumesAddon1(
            self_: *mut whiteout_M3Model,
            data: *const u16,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_billboardBehaviors_count(
            self_: *mut whiteout_M3Model,
        ) -> usize;
        pub fn whiteout_m3_M3Model_resize_billboardBehaviors(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_billboardBehaviors_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3BillboardBehavior;
        pub fn whiteout_m3_M3Model_get_trailingModels_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_trailingModels(
            self_: *mut whiteout_M3Model,
            count: usize,
        );
        pub fn whiteout_m3_M3Model_get_trailingModels_at(
            self_: *mut whiteout_M3Model,
            index: usize,
        ) -> *mut whiteout_M3TrailingModel;
        pub fn whiteout_m3_M3Model_get_m3aAnimHash(self_: *mut whiteout_M3Model) -> u32;
        pub fn whiteout_m3_M3Model_set_m3aAnimHash(self_: *mut whiteout_M3Model, value: u32);
        pub fn whiteout_m3_M3Model_get_m3aAnimHashes_count(self_: *mut whiteout_M3Model) -> usize;
        pub fn whiteout_m3_M3Model_resize_m3aAnimHashes(self_: *mut whiteout_M3Model, count: usize);
        pub fn whiteout_m3_M3Model_get_m3aAnimHashes_data(
            self_: *mut whiteout_M3Model,
        ) -> *const u32;
        pub fn whiteout_m3_M3Model_assign_m3aAnimHashes(
            self_: *mut whiteout_M3Model,
            data: *const u32,
            count: usize,
        );
        // Parser
        pub fn whiteout_m3_M3Parser_new() -> *mut whiteout_M3Parser;
        pub fn whiteout_m3_M3Parser_delete(self_: *mut whiteout_M3Parser);
        pub fn whiteout_m3_M3Parser_parse(
            self_: *mut whiteout_M3Parser,
            file_path: *const core::ffi::c_char,
        ) -> *mut whiteout_M3Model;
        pub fn whiteout_m3_M3Parser_parse_buffer(
            self_: *mut whiteout_M3Parser,
            buffer: *const u8,
            buffer_size: usize,
        ) -> *mut whiteout_M3Model;
        pub fn whiteout_m3_M3Parser_hasIssues(self_: *mut whiteout_M3Parser) -> i32;
        pub fn whiteout_m3_M3Parser_getIssues_count(self_: *mut whiteout_M3Parser) -> usize;
        pub fn whiteout_m3_M3Parser_getIssues_at(
            self_: *mut whiteout_M3Parser,
            index: usize,
        ) -> RawCString;
        // Writer
        pub fn whiteout_m3_M3Writer_new() -> *mut whiteout_M3Writer;
        pub fn whiteout_m3_M3Writer_delete(self_: *mut whiteout_M3Writer);
        pub fn whiteout_m3_M3Writer_write(
            self_: *mut whiteout_M3Writer,
            file_path: *const core::ffi::c_char,
            model: *mut whiteout_M3Model,
        );
        pub fn whiteout_m3_M3Writer_write_model(
            self_: *mut whiteout_M3Writer,
            model: *mut whiteout_M3Model,
        ) -> RawBytes;
        // AnimRefF32
        pub fn whiteout_m3_M3AnimRefF32_new() -> *mut whiteout_M3AnimRefF32;
        pub fn whiteout_m3_M3AnimRefF32_delete(self_: *mut whiteout_M3AnimRefF32);
        pub fn whiteout_m3_M3AnimRefF32_get_interpType(self_: *mut whiteout_M3AnimRefF32) -> u16;
        pub fn whiteout_m3_M3AnimRefF32_set_interpType(
            self_: *mut whiteout_M3AnimRefF32,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefF32_get_flags(self_: *mut whiteout_M3AnimRefF32) -> u16;
        pub fn whiteout_m3_M3AnimRefF32_set_flags(self_: *mut whiteout_M3AnimRefF32, value: u16);
        pub fn whiteout_m3_M3AnimRefF32_get_animId(self_: *mut whiteout_M3AnimRefF32) -> u32;
        pub fn whiteout_m3_M3AnimRefF32_set_animId(self_: *mut whiteout_M3AnimRefF32, value: u32);
        pub fn whiteout_m3_M3AnimRefF32_get_initValue(self_: *mut whiteout_M3AnimRefF32) -> f32;
        pub fn whiteout_m3_M3AnimRefF32_set_initValue(
            self_: *mut whiteout_M3AnimRefF32,
            value: f32,
        );
        pub fn whiteout_m3_M3AnimRefF32_get_nullValue(self_: *mut whiteout_M3AnimRefF32) -> f32;
        pub fn whiteout_m3_M3AnimRefF32_set_nullValue(
            self_: *mut whiteout_M3AnimRefF32,
            value: f32,
        );
        pub fn whiteout_m3_M3AnimRefF32_get_unused(self_: *mut whiteout_M3AnimRefF32) -> i32;
        pub fn whiteout_m3_M3AnimRefF32_set_unused(self_: *mut whiteout_M3AnimRefF32, value: i32);
        // AnimRefVector3f
        pub fn whiteout_m3_M3AnimRefVector3f_new() -> *mut whiteout_M3AnimRefVector3f;
        pub fn whiteout_m3_M3AnimRefVector3f_delete(self_: *mut whiteout_M3AnimRefVector3f);
        pub fn whiteout_m3_M3AnimRefVector3f_get_interpType(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefVector3f_set_interpType(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefVector3f_get_flags(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefVector3f_set_flags(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefVector3f_get_animId(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> u32;
        pub fn whiteout_m3_M3AnimRefVector3f_set_animId(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefVector3f_get_initValue(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefVector3f_set_initValue(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefVector3f_get_nullValue(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefVector3f_set_nullValue(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefVector3f_get_unused(
            self_: *mut whiteout_M3AnimRefVector3f,
        ) -> i32;
        pub fn whiteout_m3_M3AnimRefVector3f_set_unused(
            self_: *mut whiteout_M3AnimRefVector3f,
            value: i32,
        );
        // AnimRefM3ColorBGRA
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_new() -> *mut whiteout_M3AnimRefM3ColorBGRA;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_delete(self_: *mut whiteout_M3AnimRefM3ColorBGRA);
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_interpType(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_interpType(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_flags(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_flags(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_animId(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> u32;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_animId(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_initValue(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> *mut whiteout_M3ColorBGRA;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_initValue(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: *const whiteout_M3ColorBGRA,
        );
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_nullValue(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> *mut whiteout_M3ColorBGRA;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_nullValue(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: *const whiteout_M3ColorBGRA,
        );
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_get_unused(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
        ) -> i32;
        pub fn whiteout_m3_M3AnimRefM3ColorBGRA_set_unused(
            self_: *mut whiteout_M3AnimRefM3ColorBGRA,
            value: i32,
        );
        // AnimRefU16
        pub fn whiteout_m3_M3AnimRefU16_new() -> *mut whiteout_M3AnimRefU16;
        pub fn whiteout_m3_M3AnimRefU16_delete(self_: *mut whiteout_M3AnimRefU16);
        pub fn whiteout_m3_M3AnimRefU16_get_interpType(self_: *mut whiteout_M3AnimRefU16) -> u16;
        pub fn whiteout_m3_M3AnimRefU16_set_interpType(
            self_: *mut whiteout_M3AnimRefU16,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefU16_get_flags(self_: *mut whiteout_M3AnimRefU16) -> u16;
        pub fn whiteout_m3_M3AnimRefU16_set_flags(self_: *mut whiteout_M3AnimRefU16, value: u16);
        pub fn whiteout_m3_M3AnimRefU16_get_animId(self_: *mut whiteout_M3AnimRefU16) -> u32;
        pub fn whiteout_m3_M3AnimRefU16_set_animId(self_: *mut whiteout_M3AnimRefU16, value: u32);
        pub fn whiteout_m3_M3AnimRefU16_get_initValue(self_: *mut whiteout_M3AnimRefU16) -> u16;
        pub fn whiteout_m3_M3AnimRefU16_set_initValue(
            self_: *mut whiteout_M3AnimRefU16,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefU16_get_nullValue(self_: *mut whiteout_M3AnimRefU16) -> u16;
        pub fn whiteout_m3_M3AnimRefU16_set_nullValue(
            self_: *mut whiteout_M3AnimRefU16,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefU16_get_unused(self_: *mut whiteout_M3AnimRefU16) -> i32;
        pub fn whiteout_m3_M3AnimRefU16_set_unused(self_: *mut whiteout_M3AnimRefU16, value: i32);
        // AnimRefVector2f
        pub fn whiteout_m3_M3AnimRefVector2f_new() -> *mut whiteout_M3AnimRefVector2f;
        pub fn whiteout_m3_M3AnimRefVector2f_delete(self_: *mut whiteout_M3AnimRefVector2f);
        pub fn whiteout_m3_M3AnimRefVector2f_get_interpType(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefVector2f_set_interpType(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefVector2f_get_flags(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefVector2f_set_flags(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefVector2f_get_animId(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> u32;
        pub fn whiteout_m3_M3AnimRefVector2f_set_animId(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefVector2f_get_initValue(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefVector2f_set_initValue(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefVector2f_get_nullValue(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefVector2f_set_nullValue(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefVector2f_get_unused(
            self_: *mut whiteout_M3AnimRefVector2f,
        ) -> i32;
        pub fn whiteout_m3_M3AnimRefVector2f_set_unused(
            self_: *mut whiteout_M3AnimRefVector2f,
            value: i32,
        );
        // AnimRefU32
        pub fn whiteout_m3_M3AnimRefU32_new() -> *mut whiteout_M3AnimRefU32;
        pub fn whiteout_m3_M3AnimRefU32_delete(self_: *mut whiteout_M3AnimRefU32);
        pub fn whiteout_m3_M3AnimRefU32_get_interpType(self_: *mut whiteout_M3AnimRefU32) -> u16;
        pub fn whiteout_m3_M3AnimRefU32_set_interpType(
            self_: *mut whiteout_M3AnimRefU32,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefU32_get_flags(self_: *mut whiteout_M3AnimRefU32) -> u16;
        pub fn whiteout_m3_M3AnimRefU32_set_flags(self_: *mut whiteout_M3AnimRefU32, value: u16);
        pub fn whiteout_m3_M3AnimRefU32_get_animId(self_: *mut whiteout_M3AnimRefU32) -> u32;
        pub fn whiteout_m3_M3AnimRefU32_set_animId(self_: *mut whiteout_M3AnimRefU32, value: u32);
        pub fn whiteout_m3_M3AnimRefU32_get_initValue(self_: *mut whiteout_M3AnimRefU32) -> u32;
        pub fn whiteout_m3_M3AnimRefU32_set_initValue(
            self_: *mut whiteout_M3AnimRefU32,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefU32_get_nullValue(self_: *mut whiteout_M3AnimRefU32) -> u32;
        pub fn whiteout_m3_M3AnimRefU32_set_nullValue(
            self_: *mut whiteout_M3AnimRefU32,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefU32_get_unused(self_: *mut whiteout_M3AnimRefU32) -> i32;
        pub fn whiteout_m3_M3AnimRefU32_set_unused(self_: *mut whiteout_M3AnimRefU32, value: i32);
        // AnimRefQuaternion
        pub fn whiteout_m3_M3AnimRefQuaternion_new() -> *mut whiteout_M3AnimRefQuaternion;
        pub fn whiteout_m3_M3AnimRefQuaternion_delete(self_: *mut whiteout_M3AnimRefQuaternion);
        pub fn whiteout_m3_M3AnimRefQuaternion_get_interpType(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_interpType(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefQuaternion_get_flags(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_flags(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefQuaternion_get_animId(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> u32;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_animId(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefQuaternion_get_initValue(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_initValue(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefQuaternion_get_nullValue(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> *mut core::ffi::c_void;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_nullValue(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: *const core::ffi::c_void,
        );
        pub fn whiteout_m3_M3AnimRefQuaternion_get_unused(
            self_: *mut whiteout_M3AnimRefQuaternion,
        ) -> i32;
        pub fn whiteout_m3_M3AnimRefQuaternion_set_unused(
            self_: *mut whiteout_M3AnimRefQuaternion,
            value: i32,
        );
        // AnimRefM3Extent
        pub fn whiteout_m3_M3AnimRefM3Extent_new() -> *mut whiteout_M3AnimRefM3Extent;
        pub fn whiteout_m3_M3AnimRefM3Extent_delete(self_: *mut whiteout_M3AnimRefM3Extent);
        pub fn whiteout_m3_M3AnimRefM3Extent_get_interpType(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_interpType(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefM3Extent_get_flags(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> u16;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_flags(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: u16,
        );
        pub fn whiteout_m3_M3AnimRefM3Extent_get_animId(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> u32;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_animId(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: u32,
        );
        pub fn whiteout_m3_M3AnimRefM3Extent_get_initValue(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_initValue(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: *const whiteout_M3Extent,
        );
        pub fn whiteout_m3_M3AnimRefM3Extent_get_nullValue(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> *mut whiteout_M3Extent;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_nullValue(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: *const whiteout_M3Extent,
        );
        pub fn whiteout_m3_M3AnimRefM3Extent_get_unused(
            self_: *mut whiteout_M3AnimRefM3Extent,
        ) -> i32;
        pub fn whiteout_m3_M3AnimRefM3Extent_set_unused(
            self_: *mut whiteout_M3AnimRefM3Extent,
            value: i32,
        );
    }
}