m3_bindings.cpp

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2026 Fernando Sahmkow
//
// AUTOGENERATED by tools/codegen — do not edit by hand.
// Regenerate via:  python -m tools.codegen.codegen m3 --backend pybind11
//
// Source headers and `@bind` annotations live under include/whiteout/.
//
// Include order matters here:
//   1. pybind11/pybind11.h   sets up the base library
//   2. project headers       define whiteout::u32 et al used inside MAKE_OPAQUE
//   3. PYBIND11_MAKE_OPAQUE  opts out of stl.h's auto-conversion for our vectors
//   4. pybind11/stl.h, stl_bind.h   honor the opaque declarations

#include <pybind11/pybind11.h>

#include <array>
#include <cstdint>
#include <optional>
#include <sstream>
#include <string>
#include <vector>

#include <whiteout/vector_types.h>
#include <whiteout/models/m3/types.h>
#include <whiteout/models/m3/structures/anim.h>
#include <whiteout/models/m3/structures/base.h>
#include <whiteout/models/m3/structures/effect.h>
#include <whiteout/models/m3/structures/material.h>
#include <whiteout/models/m3/structures/mesh.h>
#include <whiteout/models/m3/structures/misc.h>
#include <whiteout/models/m3/structures/physics.h>
#include <whiteout/models/m3/structures/scene.h>
#include <whiteout/models/m3/structures.h>
#include <whiteout/models/m3/parser.h>
#include <whiteout/models/m3/writer.h>
#include <whiteout/interfaces.h>

PYBIND11_MAKE_OPAQUE(std::vector<std::string>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u8>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u32>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u64>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u16>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector3f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector4f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AnimRef<whiteout::f32>>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AnimRef<whiteout::Vector3f>>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AnimationGroup>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AnimationState>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AttachmentPoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::AttachmentVolume>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Batch>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::BillboardBehavior>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Bone>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::BoneAnimationSet>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Camera>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ClothCollider>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ClothPhysics>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ClothProxy>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::CompositeMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::CompositeSection>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ConvexHullHalfEdge>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::CreepMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::DisplacementMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Force>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::HairMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::HitTestShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::IKCCD>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::IKJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::IKTwoJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::InitialReference>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::LensFlare>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Light>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::MaterialAddData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::MaterialMap>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::MeshDivision>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::MeshSection>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::OneBoneSolver>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ParticleEmitter>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ParticleEmitterCopy>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::PhysicsConstraint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::PhysicsJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::PhysicsMeshBvhNode>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::PhysicsShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Projector>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ReflectionMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Region>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::RibbonEmitter>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::RigidBody>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::STBMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Sequence>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ShadowBox>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::SplineRibbon>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::StandardMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::SubFlare>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::SubTrackContainer>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::TerrainMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::TrailingModel>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::TriggerData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::TurretBehavior>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::ViewVolume>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::VolumeMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::VolumeNoiseMaterial>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m3::Warp>);

#include <pybind11/stl.h>
#include <pybind11/stl_bind.h>
#include <pybind11/operators.h>
#include <pybind11/numpy.h>

namespace py = pybind11;


namespace {

// Buffer-protocol vector wrapper for std::vector<Elem> where Elem is laid
// out as `Components` contiguous Scalars (Vector3f, Quaternion, ColorBGRA…).
//
// pybind11's bind_vector<> wires up py::buffer_protocol() automatically,
// but stl_bind.h's auto-buffer-info path static-asserts on element types
// lacking a format_descriptor — Vector3f/Quaternion don't have one.
// We provide the same Python surface (append, extend, clear, __getitem__,
// __setitem__, __iter__, __len__, __bool__) plus a 2D buffer view.
template <typename Elem, typename Scalar, py::ssize_t Components>
auto bindBufferVector(py::module_& m, const char* name) {
    using Vec = std::vector<Elem>;
    py::class_<Vec> cls(m, name, py::buffer_protocol());
    cls.def(py::init<>());
    cls.def("__len__",  [](const Vec& v) { return v.size(); });
    cls.def("__bool__", [](const Vec& v) { return !v.empty(); });
    cls.def("__getitem__", [](const Vec& v, std::size_t i) -> Elem {
        if (i >= v.size()) throw py::index_error();
        return v[i];
    });
    cls.def("__setitem__", [](Vec& v, std::size_t i, const Elem& val) {
        if (i >= v.size()) throw py::index_error();
        v[i] = val;
    });
    cls.def("__iter__", [](Vec& v) {
        return py::make_iterator(v.begin(), v.end());
    }, py::keep_alive<0, 1>());
    cls.def("append",   [](Vec& v, const Elem& val) { v.push_back(val); });
    cls.def("extend",   [](Vec& v, const Vec& o) {
        v.insert(v.end(), o.begin(), o.end());
    });
    cls.def("clear",    &Vec::clear);
    cls.def_buffer([](Vec& v) -> py::buffer_info {
        if constexpr (Components == 1) {
            return py::buffer_info(
                v.data(),
                static_cast<py::ssize_t>(sizeof(Scalar)),
                py::format_descriptor<Scalar>::format(),
                1,
                { static_cast<py::ssize_t>(v.size()) },
                { static_cast<py::ssize_t>(sizeof(Scalar)) });
        } else {
            return py::buffer_info(
                v.data(),
                static_cast<py::ssize_t>(sizeof(Scalar)),
                py::format_descriptor<Scalar>::format(),
                2,
                { static_cast<py::ssize_t>(v.size()), Components },
                { static_cast<py::ssize_t>(sizeof(Elem)),
                  static_cast<py::ssize_t>(sizeof(Scalar)) });
        }
    });
    return cls;
}

} // namespace
void bind_m3(py::module_& m) {
    py::enum_<whiteout::m3::VertexFormatFlag>(m, "VertexFormatFlag", R"doc(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.)doc")
        .value("NONE", whiteout::m3::VertexFormatFlag::None)
        .value("VERTEX_COLOR", whiteout::m3::VertexFormatFlag::VertexColor, R"doc(Bit 10 (1-based): Has vertex color (adds 4 bytes))doc")
        .value("UV1", whiteout::m3::VertexFormatFlag::UV1, R"doc(Bit 18 (1-based): Has UV layer 1 (adds 4 bytes))doc")
        .value("UV2", whiteout::m3::VertexFormatFlag::UV2, R"doc(Bit 19 (1-based): Has UV layer 2 (adds 4 bytes))doc")
        .value("UV3", whiteout::m3::VertexFormatFlag::UV3, R"doc(Bit 20 (1-based): Has UV layer 3 (adds 4 bytes))doc")
        .value("UV4", whiteout::m3::VertexFormatFlag::UV4, R"doc(Bit 21 (1-based): Has UV layer 4 (adds 4 bytes))doc")
        .value("UV5", whiteout::m3::VertexFormatFlag::UV5, R"doc(Bit 30 (1-based): Has UV layer 5 (adds 4 bytes))doc")
    ;

    py::enum_<whiteout::m3::MaterialType>(m, "MaterialType", R"doc(Identifies which material array a MATM entry references)doc")
        .value("STANDARD", whiteout::m3::MaterialType::Standard, R"doc(MAT_ — Standard material)doc")
        .value("DISPLACEMENT", whiteout::m3::MaterialType::Displacement, R"doc(DIS_ — Displacement material)doc")
        .value("COMPOSITE", whiteout::m3::MaterialType::Composite, R"doc(CMP_ — Composite material)doc")
        .value("TERRAIN", whiteout::m3::MaterialType::Terrain, R"doc(TER_ — Terrain material)doc")
        .value("VOLUME", whiteout::m3::MaterialType::Volume, R"doc(VOL_ — Volume material)doc")
        .value("VOLUME_NOISE", whiteout::m3::MaterialType::VolumeNoise, R"doc(VON_ — Volume noise material)doc")
        .value("CREEP", whiteout::m3::MaterialType::Creep, R"doc(CREP — Creep material)doc")
        .value("HAIR", whiteout::m3::MaterialType::Hair, R"doc(HAI_ — Hair material (defunct))doc")
        .value("SPLAT_TERRAIN_BAKE", whiteout::m3::MaterialType::SplatTerrainBake, R"doc(STBM — Splat terrain bake material)doc")
        .value("REFLECTION", whiteout::m3::MaterialType::Reflection, R"doc(REF_ — Reflection material)doc")
        .value("LENS_FLARE", whiteout::m3::MaterialType::LensFlare, R"doc(LFLR — Lens flare material)doc")
        .value("BUFFER_MATERIAL", whiteout::m3::MaterialType::BufferMaterial, R"doc(MADD — Buffer / additional material data)doc")
    ;

    py::enum_<whiteout::m3::LightType>(m, "LightType", R"doc(Light source type (LITE))doc")
        .value("OMNI", whiteout::m3::LightType::Omni, R"doc(Point light (omnidirectional))doc")
        .value("SPOT", whiteout::m3::LightType::Spot, R"doc(Spot light (cone))doc")
        .value("DIRECTIONAL", whiteout::m3::LightType::Directional, R"doc(Directional light (infinite distance))doc")
    ;

    py::enum_<whiteout::m3::PhysicsShapeType>(m, "PhysicsShapeType", R"doc(Physics collision shape type (PHSH))doc")
        .value("BOX", whiteout::m3::PhysicsShapeType::Box, R"doc(Box (half-extents in shapeDimensions))doc")
        .value("SPHERE", whiteout::m3::PhysicsShapeType::Sphere, R"doc(Sphere (radius in shapeDimensions.x))doc")
        .value("CAPSULE", whiteout::m3::PhysicsShapeType::Capsule, R"doc(Capsule (radius + height))doc")
        .value("CYLINDER", whiteout::m3::PhysicsShapeType::Cylinder, R"doc(Cylinder (radius + height))doc")
        .value("CONVEX_HULL", whiteout::m3::PhysicsShapeType::ConvexHull, R"doc(Convex hull (vertex/half-edge data))doc")
        .value("MESH", whiteout::m3::PhysicsShapeType::Mesh, R"doc(Triangle mesh (face/edge/normal data))doc")
    ;

    py::enum_<whiteout::m3::HitTestShapeType>(m, "HitTestShapeType", R"doc(Hit-test shape type (SSGS / ATVL), same semantics as PhysicsShapeType but u32)doc")
        .value("BOX", whiteout::m3::HitTestShapeType::Box)
        .value("SPHERE", whiteout::m3::HitTestShapeType::Sphere)
        .value("CAPSULE", whiteout::m3::HitTestShapeType::Capsule)
        .value("CYLINDER", whiteout::m3::HitTestShapeType::Cylinder)
        .value("MESH", whiteout::m3::HitTestShapeType::Mesh)
    ;

    py::enum_<whiteout::m3::EmitterShape>(m, "EmitterShape", R"doc(Particle / ribbon emitter shape (PAR_ / RIB_))doc")
        .value("POINT", whiteout::m3::EmitterShape::Point, R"doc(Emit from a single point)doc")
        .value("PLANE", whiteout::m3::EmitterShape::Plane, R"doc(Emit from a rectangular plane)doc")
        .value("SPHERE", whiteout::m3::EmitterShape::Sphere, R"doc(Emit from a sphere surface/volume)doc")
        .value("BOX", whiteout::m3::EmitterShape::Box, R"doc(Emit from a box volume)doc")
        .value("CYLINDER", whiteout::m3::EmitterShape::Cylinder, R"doc(Emit from a cylinder)doc")
        .value("DISC", whiteout::m3::EmitterShape::Disc, R"doc(Emit from a disc)doc")
        .value("SPLINE", whiteout::m3::EmitterShape::Spline, R"doc(Emit from a spline path, splineLineData)doc")
        .value("MESH", whiteout::m3::EmitterShape::Mesh, R"doc(Emit from mesh surface, mesh region indices in shapeRegions)doc")
    ;

    py::enum_<whiteout::m3::ParticleInstanceType>(m, "ParticleInstanceType", R"doc(Particle visual / billboard type (maps to b_iInstanceType in Particle.fx))doc")
        .value("BILLBOARD", whiteout::m3::ParticleInstanceType::Billboard, R"doc(Camera-facing billboard quad)doc")
        .value("TAIL", whiteout::m3::ParticleInstanceType::Tail, R"doc(Velocity-stretched quad)doc")
        .value("FACE_TRAVEL_DIR", whiteout::m3::ParticleInstanceType::FaceTravelDir, R"doc(Quad oriented along instantaneous velocity)doc")
        .value("FACE_WORLD_DIR", whiteout::m3::ParticleInstanceType::FaceWorldDir, R"doc(Quad oriented along a fixed world direction)doc")
        .value("SINGLE_AXIS", whiteout::m3::ParticleInstanceType::SingleAxis, R"doc(Billboard locked to a single rotation axis)doc")
        .value("TERRAIN_ORIENTED", whiteout::m3::ParticleInstanceType::TerrainOriented, R"doc(Quad projected onto terrain normal)doc")
        .value("TERRAIN_DIR_ORIENTED", whiteout::m3::ParticleInstanceType::TerrainDirOriented, R"doc(Terrain-oriented + velocity-stretched)doc")
        .value("EMITTER_ORIENTED", whiteout::m3::ParticleInstanceType::EmitterOriented, R"doc(Quad uses the emitter bone's orientation)doc")
        .value("PHYSICS_ORIENTED", whiteout::m3::ParticleInstanceType::PhysicsOriented, R"doc(Quad oriented by physics simulation)doc")
        .value("PINNED", whiteout::m3::ParticleInstanceType::Pinned, R"doc(Stretch between spawn origin and current position)doc")
        .value("TRAIL", whiteout::m3::ParticleInstanceType::Trail, R"doc(Like Tail but offset by one tail-length)doc")
    ;

    py::enum_<whiteout::m3::ForceType>(m, "ForceType", R"doc(Force influence type (FOR_))doc")
        .value("RADIAL", whiteout::m3::ForceType::Radial, R"doc(Radial force (outward from center))doc")
        .value("WIND", whiteout::m3::ForceType::Wind, R"doc(Wind force (directional))doc")
        .value("EXPLOSION", whiteout::m3::ForceType::Explosion, R"doc(Explosion force (impulse))doc")
    ;

    py::enum_<whiteout::m3::ForceShape>(m, "ForceShape", R"doc(Influence volume shape for a force (FOR_))doc")
        .value("SPHERE", whiteout::m3::ForceShape::Sphere, R"doc(Spherical influence volume)doc")
        .value("CYLINDER", whiteout::m3::ForceShape::Cylinder, R"doc(Cylindrical influence volume)doc")
        .value("BOX", whiteout::m3::ForceShape::Box, R"doc(Box influence volume)doc")
        .value("HEMISPHERE", whiteout::m3::ForceShape::Hemisphere, R"doc(Hemispherical influence volume)doc")
    ;

    py::enum_<whiteout::m3::RibbonType>(m, "RibbonType", R"doc(Ribbon cross-section type (maps to b_iRibbonType in Ribbon.fx))doc")
        .value("BILLBOARD", whiteout::m3::RibbonType::Billboard, R"doc(Camera-facing ribbon strip)doc")
        .value("PLANAR", whiteout::m3::RibbonType::Planar, R"doc(Flat/planar ribbon strip)doc")
        .value("CYLINDER", whiteout::m3::RibbonType::Cylinder, R"doc(Cylindrical cross-section)doc")
        .value("STAR", whiteout::m3::RibbonType::Star, R"doc(Star-shaped cross-section)doc")
    ;

    py::enum_<whiteout::m3::ProjectionType>(m, "ProjectionType", R"doc(Projector / decal projection type (PROJ))doc")
        .value("ORTHOGRAPHIC", whiteout::m3::ProjectionType::Orthographic, R"doc(Orthographic projection)doc")
        .value("PERSPECTIVE", whiteout::m3::ProjectionType::Perspective, R"doc(Perspective projection)doc")
    ;

    py::enum_<whiteout::m3::VolumeType>(m, "VolumeType", R"doc(Volume shape type (VOL_ / VON_))doc")
        .value("BOX", whiteout::m3::VolumeType::Box)
        .value("SPHERE", whiteout::m3::VolumeType::Sphere)
        .value("CAPSULE", whiteout::m3::VolumeType::Capsule)
    ;

    py::enum_<whiteout::m3::InterpolationMode>(m, "InterpolationMode", R"doc(Interpolation mode for particle/ribbon smoothing curves

Maps to RibbonParticleCommon.fx constants. Used by PAR_ colorSmoothing / sizeSmoothing / rotationSmoothing and RIB_ sizeSmoothing / colorSmoothing.)doc")
        .value("LINEAR", whiteout::m3::InterpolationMode::Linear, R"doc(ITERPOLATION_LINEAR)doc")
        .value("LINEAR_SMOOTH", whiteout::m3::InterpolationMode::LinearSmooth, R"doc(ITERPOLATION_LINEAR_SMOOTH)doc")
        .value("BEZIER", whiteout::m3::InterpolationMode::Bezier, R"doc(ITERPOLATION_BEZIER)doc")
        .value("LINEAR_WITH_HOLD", whiteout::m3::InterpolationMode::LinearWithHold, R"doc(ITERPOLATION_LINEAR_WITH_HOLD)doc")
        .value("BEZIER_WITH_HOLD", whiteout::m3::InterpolationMode::BezierWithHold, R"doc(ITERPOLATION_BEZIER_WITH_HOLD)doc")
    ;

    py::enum_<whiteout::m3::ModelFlag>(m, "ModelFlag", R"doc(Model-wide flags (MODL.flags) — tangents, FOW, instancing, etc.)doc")
        .value("NONE", whiteout::m3::ModelFlag::None)
        .value("TANGENTS", whiteout::m3::ModelFlag::Tangents, R"doc(Tangents computed)doc")
        .value("BONES_FIXED", whiteout::m3::ModelFlag::BonesFixed, R"doc(Bone transforms fixed)doc")
        .value("UV_DENSITIES_COMPUTED", whiteout::m3::ModelFlag::UVDensitiesComputed, R"doc(UV densities computed)doc")
        .value("RELATIVE_BOUNDS", whiteout::m3::ModelFlag::RelativeBounds, R"doc(Uses relative bounds)doc")
        .value("SECTION_BOUNDS_FIXED", whiteout::m3::ModelFlag::SectionBoundsFixed, R"doc(Section bounds fixed)doc")
        .value("TRACK_SETS_COMPUTED", whiteout::m3::ModelFlag::TrackSetsComputed, R"doc(Track sets computed)doc")
        .value("TRACK_COLLECTION_SORTED", whiteout::m3::ModelFlag::TrackCollectionSorted, R"doc(Track collection sorted)doc")
        .value("ACCEPTS_SPLATS", whiteout::m3::ModelFlag::AcceptsSplats, R"doc(Model accepts splats)doc")
        .value("TRACK_ANIMATED_BASE_FLAG_VALID", whiteout::m3::ModelFlag::TrackAnimatedBaseFlagValid, R"doc(Animated base flag valid)doc")
        .value("FILE_DIRTY", whiteout::m3::ModelFlag::FileDirty, R"doc(File marked dirty)doc")
        .value("FOW_DO_NOT_USE_TINT", whiteout::m3::ModelFlag::FowDoNotUseTint, R"doc(FOW: do not tint)doc")
        .value("INSTANCED_VB", whiteout::m3::ModelFlag::InstancedVB, R"doc(Uses instanced vertex buffer)doc")
        .value("FORCE_SAMPLED_FOW", whiteout::m3::ModelFlag::ForceSampledFOW, R"doc(Force sampled FOW)doc")
        .value("INSTANCED_MODEL", whiteout::m3::ModelFlag::InstancedModel, R"doc(Instanced model)doc")
        .value("NEVER_USE_FOW", whiteout::m3::ModelFlag::NeverUseFOW, R"doc(Never use FOW)doc")
        .value("BONE_ANIMATED_FLAG_SOLVED", whiteout::m3::ModelFlag::BoneAnimatedFlagSolved, R"doc(Bone animated flags solved)doc")
        .value("ALLOW_LOCAL_LIGHT_SHADOWS", whiteout::m3::ModelFlag::AllowLocalLightShadows, R"doc(Allow local light shadows)doc")
        .value("AVOID_SAMPLED_FOW", whiteout::m3::ModelFlag::AvoidSampledFOW, R"doc(Avoid sampled FOW)doc")
    ;

    py::enum_<whiteout::m3::SequenceFlag>(m, "SequenceFlag", R"doc(Sequence playback flags (SEQS.flags))doc")
        .value("NONE", whiteout::m3::SequenceFlag::None)
        .value("NOT_LOOPING", whiteout::m3::SequenceFlag::NotLooping, R"doc(Sequence does not loop)doc")
        .value("ALWAYS_GLOBAL", whiteout::m3::SequenceFlag::AlwaysGlobal, R"doc(Always plays globally)doc")
        .value("UNKNOWN0X4", whiteout::m3::SequenceFlag::Unknown0x4, R"doc(Unknown)doc")
        .value("GLOBAL_IN_PREVIEWER", whiteout::m3::SequenceFlag::GlobalInPreviewer, R"doc(Global playback in editor)doc")
    ;

    py::enum_<whiteout::m3::BoneFlag>(m, "BoneFlag", R"doc(Bone flags (BONE.flags) — inheritance, billboard, IK, skin)doc")
        .value("NONE", whiteout::m3::BoneFlag::None)
        .value("INHERIT_TRANSLATION", whiteout::m3::BoneFlag::InheritTranslation, R"doc(Inherit parent translation)doc")
        .value("INHERIT_SCALE", whiteout::m3::BoneFlag::InheritScale, R"doc(Inherit parent scale)doc")
        .value("INHERIT_ROTATION", whiteout::m3::BoneFlag::InheritRotation, R"doc(Inherit parent rotation)doc")
        .value("BILLBOARD1", whiteout::m3::BoneFlag::Billboard1, R"doc(Billboard mode 1)doc")
        .value("BILLBOARD2", whiteout::m3::BoneFlag::Billboard2, R"doc(Billboard mode 2)doc")
        .value("PROJECT2_D", whiteout::m3::BoneFlag::Project2D, R"doc(2D projection mode)doc")
        .value("ANIMATED", whiteout::m3::BoneFlag::Animated, R"doc(Has animation data)doc")
        .value("INVERSE_KINEMATICS", whiteout::m3::BoneFlag::InverseKinematics, R"doc(IK bone)doc")
        .value("SKINNED", whiteout::m3::BoneFlag::Skinned, R"doc(Affects mesh skin)doc")
        .value("REAL", whiteout::m3::BoneFlag::Real, R"doc(Real bone (not helper))doc")
        .value("BATCH1", whiteout::m3::BoneFlag::Batch1, R"doc(Primary batch bone)doc")
        .value("BATCH2", whiteout::m3::BoneFlag::Batch2, R"doc(Descendant of batch1 bone)doc")
    ;

    py::enum_<whiteout::m3::RegionFlag>(m, "RegionFlag", R"doc(Region flags (REGN.flags, v4+))doc")
        .value("NONE", whiteout::m3::RegionFlag::None)
        .value("HIDDEN", whiteout::m3::RegionFlag::Hidden, R"doc(Region is hidden)doc")
        .value("PLACEHOLDER", whiteout::m3::RegionFlag::Placeholder, R"doc(Placeholder region)doc")
        .value("CLOTH_SIMULATED", whiteout::m3::RegionFlag::ClothSimulated, R"doc(Cloth-simulated)doc")
        .value("CLOTH_INFLUENCED", whiteout::m3::RegionFlag::ClothInfluenced, R"doc(Cloth-influenced)doc")
    ;

    py::enum_<whiteout::m3::MaterialAdditionalFlag>(m, "MaterialAdditionalFlag", R"doc(Additional standard-material flags (MAT_.additionalFlags))doc")
        .value("NONE", whiteout::m3::MaterialAdditionalFlag::None)
        .value("DEPTH_BLEND_FALLOFF", whiteout::m3::MaterialAdditionalFlag::DepthBlendFalloff, R"doc(Enable depth blend falloff)doc")
        .value("VERTEX_COLOR", whiteout::m3::MaterialAdditionalFlag::VertexColor, R"doc(Uses vertex color)doc")
        .value("VERTEX_ALPHA", whiteout::m3::MaterialAdditionalFlag::VertexAlpha, R"doc(Uses vertex alpha)doc")
    ;

    py::enum_<whiteout::m3::MaterialFlag>(m, "MaterialFlag", R"doc(Standard material rendering flags (MAT_.flags))doc")
        .value("NONE", whiteout::m3::MaterialFlag::None)
        .value("VERTEX_COLOR", whiteout::m3::MaterialFlag::VertexColor, R"doc(Enable vertex color)doc")
        .value("VERTEX_ALPHA", whiteout::m3::MaterialFlag::VertexAlpha, R"doc(Enable vertex alpha)doc")
        .value("UNFOGGED", whiteout::m3::MaterialFlag::Unfogged, R"doc(Not affected by fog)doc")
        .value("TWO_SIDED", whiteout::m3::MaterialFlag::TwoSided, R"doc(Two-sided rendering)doc")
        .value("UNSHADED", whiteout::m3::MaterialFlag::Unshaded, R"doc(Unlit / unshaded)doc")
        .value("NO_SHADOWS_CAST", whiteout::m3::MaterialFlag::NoShadowsCast, R"doc(Does not cast shadows)doc")
        .value("NO_HIT_TEST", whiteout::m3::MaterialFlag::NoHitTest, R"doc(Excluded from hit testing)doc")
        .value("NO_SHADOWS_RECEIVE", whiteout::m3::MaterialFlag::NoShadowsReceive, R"doc(Does not receive shadows)doc")
        .value("DEPTH_PREPASS", whiteout::m3::MaterialFlag::DepthPrepass, R"doc(Z-fill pre-pass)doc")
        .value("TERRAIN_HDR", whiteout::m3::MaterialFlag::TerrainHDR, R"doc(Terrain HDR mode)doc")
        .value("SIMULATE_ROUGHNESS", whiteout::m3::MaterialFlag::SimulateRoughness, R"doc(Simulate roughness)doc")
        .value("PIXEL_FORWARD_LIGHTING", whiteout::m3::MaterialFlag::PixelForwardLighting, R"doc(Pixel forward lighting)doc")
        .value("DEPTH_FOG", whiteout::m3::MaterialFlag::DepthFog, R"doc(Depth-based fog)doc")
        .value("TRANSPARENT_SHADOWS", whiteout::m3::MaterialFlag::TransparentShadows, R"doc(Transparent shadows)doc")
        .value("DECAL_LIGHTING", whiteout::m3::MaterialFlag::DecalLighting, R"doc(Decal lighting mode)doc")
        .value("TRANSPARENT_DEPTH_EFFECTS", whiteout::m3::MaterialFlag::TransparentDepthEffects, R"doc(Transparent depth effects)doc")
        .value("TRANSPARENT_LOCAL_LIGHTS", whiteout::m3::MaterialFlag::TransparentLocalLights, R"doc(Transparent local lights)doc")
        .value("DISABLE_SOFT", whiteout::m3::MaterialFlag::DisableSoft, R"doc(Disable soft blending)doc")
        .value("DOUBLE_LAMBERT", whiteout::m3::MaterialFlag::DoubleLambert, R"doc(Double Lambert shading)doc")
        .value("HAIR_LAYER_SORTING", whiteout::m3::MaterialFlag::HairLayerSorting, R"doc(Hair layer sorting)doc")
        .value("ACCEPT_SPLATS", whiteout::m3::MaterialFlag::AcceptSplats, R"doc(Accept splat projections)doc")
        .value("DECAL_LOW_REQUIRED", whiteout::m3::MaterialFlag::DecalLowRequired, R"doc(Decal low LOD required)doc")
        .value("EMIS_LOW_REQUIRED", whiteout::m3::MaterialFlag::EmisLowRequired, R"doc(Emissive low LOD required)doc")
        .value("SPEC_LOW_REQUIRED", whiteout::m3::MaterialFlag::SpecLowRequired, R"doc(Specular low LOD required)doc")
        .value("ACCEPT_SPLATS_ONLY", whiteout::m3::MaterialFlag::AcceptSplatsOnly, R"doc(Accept splats only)doc")
        .value("BACKGROUND_OBJECT", whiteout::m3::MaterialFlag::BackgroundObject, R"doc(Background object)doc")
        .value("DEPTH_PREPASS_LOW_REQUIRED", whiteout::m3::MaterialFlag::DepthPrepassLowRequired, R"doc(Depth prepass low LOD)doc")
        .value("NO_HIGHLIGHTING", whiteout::m3::MaterialFlag::NoHighlighting, R"doc(Disable highlighting)doc")
        .value("CLAMP_OUTPUT", whiteout::m3::MaterialFlag::ClampOutput, R"doc(Clamp output)doc")
        .value("GEOMETRY_VISIBLE", whiteout::m3::MaterialFlag::GeometryVisible, R"doc(Geometry visible (v17+))doc")
    ;

    py::enum_<whiteout::m3::TextureLayerFlag>(m, "TextureLayerFlag", R"doc(Texture layer flags (LAYR.flags))doc")
        .value("NONE", whiteout::m3::TextureLayerFlag::None)
        .value("UV_WRAP_X", whiteout::m3::TextureLayerFlag::UVWrapX, R"doc(Wrap texture in U)doc")
        .value("UV_WRAP_Y", whiteout::m3::TextureLayerFlag::UVWrapY, R"doc(Wrap texture in V)doc")
        .value("COLOR_INVERT", whiteout::m3::TextureLayerFlag::ColorInvert, R"doc(Invert color)doc")
        .value("COLOR_CLAMP", whiteout::m3::TextureLayerFlag::ColorClamp, R"doc(Clamp to [0,1])doc")
        .value("COLOR_ADD", whiteout::m3::TextureLayerFlag::ColorAdd, R"doc(Additive blending)doc")
        .value("COLOR_MULTIPLY", whiteout::m3::TextureLayerFlag::ColorMultiply, R"doc(Multiplicative blending)doc")
        .value("PARTICLE_UV_FLIPBOOK", whiteout::m3::TextureLayerFlag::ParticleUVFlipbook, R"doc(Flipbook UVs for particles)doc")
        .value("VIDEO", whiteout::m3::TextureLayerFlag::Video, R"doc(Video texture)doc")
        .value("COLOR", whiteout::m3::TextureLayerFlag::Color, R"doc(Solid color (no texture))doc")
        .value("REPLACE_TEXTURE_SOURCE", whiteout::m3::TextureLayerFlag::ReplaceTextureSource, R"doc(Override texture source)doc")
        .value("FRESNEL_TRANSFORM", whiteout::m3::TextureLayerFlag::FresnelTransform, R"doc(Fresnel-based UV transform)doc")
        .value("FRESNEL_NORMALIZE", whiteout::m3::TextureLayerFlag::FresnelNormalize, R"doc(Normalize fresnel values)doc")
    ;

    py::enum_<whiteout::m3::BlendMode>(m, "BlendMode", R"doc(Blend mode for materials (MAT_.blendMode, VOL_.blendMode))doc")
        .value("OPAQUE", whiteout::m3::BlendMode::Opaque, R"doc(Fully opaque)doc")
        .value("ALPHA_BLEND", whiteout::m3::BlendMode::AlphaBlend, R"doc(Standard alpha blending)doc")
        .value("ADD", whiteout::m3::BlendMode::Add, R"doc(Additive blending)doc")
        .value("ALPHA_ADD", whiteout::m3::BlendMode::AlphaAdd, R"doc(Alpha-modulated additive)doc")
        .value("MOD", whiteout::m3::BlendMode::Mod, R"doc(Multiplicative blending)doc")
        .value("MOD2X", whiteout::m3::BlendMode::Mod2x, R"doc(Double multiplicative)doc")
    ;

    py::enum_<whiteout::m3::MaterialClass>(m, "MaterialClass", R"doc(Material rendering class (MAT_.materialClass))doc")
        .value("UNIT", whiteout::m3::MaterialClass::Unit, R"doc(Unit/character material)doc")
        .value("BUILDING", whiteout::m3::MaterialClass::Building, R"doc(Building/structure material)doc")
        .value("DOODAD", whiteout::m3::MaterialClass::Doodad, R"doc(Doodad/prop material)doc")
        .value("SPECIAL_FX", whiteout::m3::MaterialClass::SpecialFX, R"doc(Special effect material)doc")
    ;

    py::enum_<whiteout::m3::LayerBlendOp>(m, "LayerBlendOp", R"doc(Layer blend operation (MAT_.layerBlendMode, emissiveBlendMode))doc")
        .value("MOD", whiteout::m3::LayerBlendOp::Mod, R"doc(Multiply: base * layer)doc")
        .value("MOD2X", whiteout::m3::LayerBlendOp::Mod2x, R"doc(Double multiply: base * layer * 2)doc")
        .value("ADD", whiteout::m3::LayerBlendOp::Add, R"doc(Add: base + layer)doc")
        .value("LERP", whiteout::m3::LayerBlendOp::Lerp, R"doc(Linear interpolate by layer alpha)doc")
        .value("TEAM_COLOR_EMISSIVE_ADD", whiteout::m3::LayerBlendOp::TeamColorEmissiveAdd, R"doc(Team color emissive add)doc")
        .value("TEAM_COLOR_DIFFUSE_ADD", whiteout::m3::LayerBlendOp::TeamColorDiffuseAdd, R"doc(Team color diffuse add)doc")
        .value("ADD_NO_ALPHA", whiteout::m3::LayerBlendOp::AddNoAlpha, R"doc(Add ignoring alpha channel)doc")
    ;

    py::enum_<whiteout::m3::UVMappingMode>(m, "UVMappingMode", R"doc(UV mapping source / projection mode (LAYR.uvMapping))doc")
        .value("EXPLICIT_UV0", whiteout::m3::UVMappingMode::ExplicitUV0, R"doc(UV coordinate set 0)doc")
        .value("EXPLICIT_UV1", whiteout::m3::UVMappingMode::ExplicitUV1, R"doc(UV coordinate set 1)doc")
        .value("REFLECT_CUBIC_ENVIO", whiteout::m3::UVMappingMode::ReflectCubicEnvio, R"doc(Cubic environment reflection)doc")
        .value("REFLECT_SPHERICAL_ENVIO", whiteout::m3::UVMappingMode::ReflectSphericalEnvio, R"doc(Spherical environment reflection)doc")
        .value("PLANAR_LOCAL_Z", whiteout::m3::UVMappingMode::PlanarLocalZ, R"doc(Planar local UVs (Z plane))doc")
        .value("PLANAR_WORLD_Z", whiteout::m3::UVMappingMode::PlanarWorldZ, R"doc(Planar world UVs (Z plane))doc")
        .value("PARTICLE_FLIPBOOK", whiteout::m3::UVMappingMode::ParticleFlipbook, R"doc(Particle flipbook UVs)doc")
        .value("CUBIC_ENVIO", whiteout::m3::UVMappingMode::CubicEnvio, R"doc(Cubic environment mapping)doc")
        .value("SPHERICAL_ENVIO", whiteout::m3::UVMappingMode::SphericalEnvio, R"doc(Spherical environment mapping)doc")
        .value("EXPLICIT_UV2", whiteout::m3::UVMappingMode::ExplicitUV2, R"doc(UV coordinate set 2)doc")
        .value("EXPLICIT_UV3", whiteout::m3::UVMappingMode::ExplicitUV3, R"doc(UV coordinate set 3)doc")
        .value("PLANAR_LOCAL_X", whiteout::m3::UVMappingMode::PlanarLocalX, R"doc(Planar local UVs (X plane))doc")
        .value("PLANAR_LOCAL_Y", whiteout::m3::UVMappingMode::PlanarLocalY, R"doc(Planar local UVs (Y plane))doc")
        .value("PLANAR_WORLD_X", whiteout::m3::UVMappingMode::PlanarWorldX, R"doc(Planar world UVs (X plane))doc")
        .value("PLANAR_WORLD_Y", whiteout::m3::UVMappingMode::PlanarWorldY, R"doc(Planar world UVs (Y plane))doc")
        .value("SCREEN_SPACE", whiteout::m3::UVMappingMode::ScreenSpace, R"doc(Screen-space UVs)doc")
        .value("TRI_PLANAR_LOCAL", whiteout::m3::UVMappingMode::TriPlanarLocal, R"doc(Tri-planar blending (local space))doc")
        .value("TRI_PLANAR_WORLD", whiteout::m3::UVMappingMode::TriPlanarWorld, R"doc(Tri-planar blending (world space))doc")
        .value("TRI_PLANAR_WORLD_LOCAL_Z", whiteout::m3::UVMappingMode::TriPlanarWorldLocalZ, R"doc(Tri-planar world with local Z)doc")
    ;

    py::enum_<whiteout::m3::ColorChannelSelect>(m, "ColorChannelSelect", R"doc(Color channel selection (LAYR.colorType))doc")
        .value("RGB", whiteout::m3::ColorChannelSelect::RGB, R"doc(Use RGB channels (alpha forced to 1))doc")
        .value("RGBA", whiteout::m3::ColorChannelSelect::RGBA, R"doc(Use all RGBA channels)doc")
        .value("ALPHA", whiteout::m3::ColorChannelSelect::Alpha, R"doc(Use alpha channel only (splat to all))doc")
        .value("RED", whiteout::m3::ColorChannelSelect::Red, R"doc(Use red channel only (splat to all))doc")
        .value("GREEN", whiteout::m3::ColorChannelSelect::Green, R"doc(Use green channel only (splat to all))doc")
        .value("BLUE", whiteout::m3::ColorChannelSelect::Blue, R"doc(Use blue channel only (splat to all))doc")
    ;

    py::enum_<whiteout::m3::SpecularMode>(m, "SpecularMode", R"doc(Specular mode (MAT_.specularMode))doc")
        .value("RGB", whiteout::m3::SpecularMode::RGB, R"doc(Use RGB channels for specularity)doc")
        .value("ALPHA_ONLY", whiteout::m3::SpecularMode::AlphaOnly, R"doc(Use alpha channel only)doc")
    ;

    py::enum_<whiteout::m3::FresnelMode>(m, "FresnelMode", R"doc(Fresnel effect mode (LAYR.fresnelMode))doc")
        .value("NONE", whiteout::m3::FresnelMode::None, R"doc(No fresnel effect)doc")
        .value("STANDARD", whiteout::m3::FresnelMode::Standard, R"doc(Standard fresnel (edge glow))doc")
        .value("INVERTED", whiteout::m3::FresnelMode::Inverted, R"doc(Inverted fresnel (center glow))doc")
    ;

    py::enum_<whiteout::m3::ReflectionMaterialFlag>(m, "ReflectionMaterialFlag", R"doc(Reflection material flags (REF_.flags, v2+))doc")
        .value("NONE", whiteout::m3::ReflectionMaterialFlag::None)
        .value("USE_REFLECTION_MAP", whiteout::m3::ReflectionMaterialFlag::UseReflectionMap, R"doc(Use reflection map)doc")
        .value("USE_DISPLACEMENT_MAP", whiteout::m3::ReflectionMaterialFlag::UseDisplacementMap, R"doc(Use displacement map)doc")
        .value("RENDER_IN_TRANSPARENT_PASS", whiteout::m3::ReflectionMaterialFlag::RenderInTransparentPass, R"doc(Render in transparent pass)doc")
        .value("BLURRING", whiteout::m3::ReflectionMaterialFlag::Blurring, R"doc(Enable blurring)doc")
        .value("USE_BLUR_MAP", whiteout::m3::ReflectionMaterialFlag::UseBlurMap, R"doc(Use blur map)doc")
    ;

    py::enum_<whiteout::m3::VolumeNoiseMaterialFlag>(m, "VolumeNoiseMaterialFlag", R"doc(Volume noise material flags (VON_.flags))doc")
        .value("NONE", whiteout::m3::VolumeNoiseMaterialFlag::None)
        .value("DRAW_AFTER_TRANSPARENCY", whiteout::m3::VolumeNoiseMaterialFlag::DrawAfterTransparency, R"doc(Draw in separate pass after transparency)doc")
    ;

    py::enum_<whiteout::m3::VolumeFalloffType>(m, "VolumeFalloffType", R"doc(Volume density falloff type (VOL_.falloffType, VON_.falloffType))doc")
        .value("LINEAR", whiteout::m3::VolumeFalloffType::Linear, R"doc(Linear density falloff)doc")
        .value("EXPONENTIAL", whiteout::m3::VolumeFalloffType::Exponential, R"doc(Exponential density falloff)doc")
    ;

    py::enum_<whiteout::m3::VolumeNoiseCameraMode>(m, "VolumeNoiseCameraMode", R"doc(Volume noise camera position mode (VON_.drawTransparency))doc")
        .value("OUTSIDE", whiteout::m3::VolumeNoiseCameraMode::Outside, R"doc(Camera is outside the volume)doc")
        .value("INSIDE", whiteout::m3::VolumeNoiseCameraMode::Inside, R"doc(Camera is inside the volume)doc")
    ;

    py::enum_<whiteout::m3::LightFlag>(m, "LightFlag", R"doc(Light flags (LITE.flags))doc")
        .value("NONE", whiteout::m3::LightFlag::None)
        .value("SHADOWS", whiteout::m3::LightFlag::Shadows, R"doc(Casts shadows)doc")
        .value("SPECULAR", whiteout::m3::LightFlag::Specular, R"doc(Specular component)doc")
        .value("AMBIENT_OCCLUSION", whiteout::m3::LightFlag::AmbientOcclusion, R"doc(AO influence)doc")
        .value("LIGHT_OPAQUE", whiteout::m3::LightFlag::LightOpaque, R"doc(Lights opaque objects)doc")
        .value("LIGHT_TRANSPARENT", whiteout::m3::LightFlag::LightTransparent, R"doc(Lights transparent objects)doc")
        .value("TEAM_COLOR", whiteout::m3::LightFlag::TeamColor, R"doc(Uses team color)doc")
    ;

    py::enum_<whiteout::m3::ParticleFlag>(m, "ParticleFlag", R"doc(Particle emitter main flags (PAR_.flags))doc")
        .value("NONE", whiteout::m3::ParticleFlag::None)
        .value("SORT", whiteout::m3::ParticleFlag::Sort, R"doc(Sort by distance)doc")
        .value("COLLIDE_TERRAIN", whiteout::m3::ParticleFlag::CollideTerrain, R"doc(Collide with terrain)doc")
        .value("COLLIDE_OBJECTS", whiteout::m3::ParticleFlag::CollideObjects, R"doc(Collide with objects)doc")
        .value("COLLIDE_EMIT", whiteout::m3::ParticleFlag::CollideEmit, R"doc(Emit on collision)doc")
        .value("EMIT_SHAPE_CUTOUT", whiteout::m3::ParticleFlag::EmitShapeCutout, R"doc(Emit from shape cutout)doc")
        .value("INHERIT_EMIT_PARAMS", whiteout::m3::ParticleFlag::InheritEmitParams, R"doc(Inherit emission parameters)doc")
        .value("INHERIT_PARENT_VELOCITY", whiteout::m3::ParticleFlag::InheritParentVelocity, R"doc(Inherit parent velocity)doc")
        .value("SORT_HEIGHT", whiteout::m3::ParticleFlag::SortHeight, R"doc(Sort by height)doc")
        .value("SORT_REVERSE", whiteout::m3::ParticleFlag::SortReverse, R"doc(Reverse sort order)doc")
        .value("OLD_ROTATION_SMOOTH", whiteout::m3::ParticleFlag::OldRotationSmooth, R"doc(Legacy rotation smoothing)doc")
        .value("OLD_ROTATION_BEZIER", whiteout::m3::ParticleFlag::OldRotationBezier, R"doc(Legacy rotation bezier)doc")
        .value("OLD_SIZE_SMOOTH", whiteout::m3::ParticleFlag::OldSizeSmooth, R"doc(Legacy size smoothing)doc")
        .value("OLD_SIZE_BEZIER", whiteout::m3::ParticleFlag::OldSizeBezier, R"doc(Legacy size bezier)doc")
        .value("OLD_COLOR_SMOOTH", whiteout::m3::ParticleFlag::OldColorSmooth, R"doc(Legacy color smoothing)doc")
        .value("OLD_COLOR_BEZIER", whiteout::m3::ParticleFlag::OldColorBezier, R"doc(Legacy color bezier)doc")
        .value("LIT_PARTS", whiteout::m3::ParticleFlag::LitParts, R"doc(Lit particles)doc")
        .value("RANDOM_FLIPBOOK_START", whiteout::m3::ParticleFlag::RandomFlipbookStart, R"doc(Random flipbook start)doc")
        .value("MULTIPLY_GRAVITY_BY_MASS", whiteout::m3::ParticleFlag::MultiplyGravityByMass, R"doc(Multiply gravity by mass)doc")
        .value("CLAMP_TAIL_LENGTH", whiteout::m3::ParticleFlag::ClampTailLength, R"doc(Clamp tail length)doc")
        .value("SPAWN_TRAILING_PARTICLES", whiteout::m3::ParticleFlag::SpawnTrailingParticles, R"doc(Spawn trailing particles)doc")
        .value("FIX_TAIL_LENGTH_ON_CREATION", whiteout::m3::ParticleFlag::FixTailLengthOnCreation, R"doc(Fix tail length on creation)doc")
        .value("USE_VERTEX_ALPHA", whiteout::m3::ParticleFlag::UseVertexAlpha, R"doc(Use vertex alpha)doc")
        .value("MODEL_PARTICLES", whiteout::m3::ParticleFlag::ModelParticles, R"doc(Use model particles)doc")
        .value("SWAP_YZ_ON_MODEL_PARTICLES", whiteout::m3::ParticleFlag::SwapYZOnModelParticles, R"doc(Swap Y/Z on model particles)doc")
        .value("SCALE_TIME_BY_PARENT", whiteout::m3::ParticleFlag::ScaleTimeByParent, R"doc(Scale time by parent)doc")
        .value("USE_LOCAL_TIME", whiteout::m3::ParticleFlag::UseLocalTime, R"doc(Use local time)doc")
        .value("SIMULATE_INIT", whiteout::m3::ParticleFlag::SimulateInit, R"doc(Simulate on initialization)doc")
        .value("COPY", whiteout::m3::ParticleFlag::Copy, R"doc(Copy emitter)doc")
    ;

    py::enum_<whiteout::m3::ParticleAdditionalFlag>(m, "ParticleAdditionalFlag", R"doc(Particle emitter additional flags (PAR_.additionalFlags, v17+))doc")
        .value("NONE", whiteout::m3::ParticleAdditionalFlag::None)
        .value("EMIT_SPEED_RANDOMIZE", whiteout::m3::ParticleAdditionalFlag::EmitSpeedRandomize, R"doc(Randomize emission speed)doc")
        .value("LIFESPAN_RANDOMIZE", whiteout::m3::ParticleAdditionalFlag::LifespanRandomize, R"doc(Randomize lifespan)doc")
        .value("MASS_RANDOMIZE", whiteout::m3::ParticleAdditionalFlag::MassRandomize, R"doc(Randomize mass)doc")
        .value("WORLD_SPACE", whiteout::m3::ParticleAdditionalFlag::WorldSpace, R"doc(World-space coordinates)doc")
    ;

    py::enum_<whiteout::m3::ParticleRotationFlag>(m, "ParticleRotationFlag", R"doc(Particle rotation flags (PAR_.rotationFlags, v18+))doc")
        .value("NONE", whiteout::m3::ParticleRotationFlag::None)
        .value("RELATIVE", whiteout::m3::ParticleRotationFlag::Relative, R"doc(Relative rotation)doc")
        .value("ALWAYS_SET", whiteout::m3::ParticleRotationFlag::AlwaysSet, R"doc(Always set)doc")
    ;

    py::enum_<whiteout::m3::RibbonFlag>(m, "RibbonFlag", R"doc(Ribbon emitter main flags (RIB_.flags))doc")
        .value("NONE", whiteout::m3::RibbonFlag::None)
        .value("COLLIDE_TERRAIN", whiteout::m3::RibbonFlag::CollideTerrain, R"doc(Collide with terrain)doc")
        .value("COLLIDE_OBJECTS", whiteout::m3::RibbonFlag::CollideObjects, R"doc(Collide with objects)doc")
        .value("EDGE_FALLOFF", whiteout::m3::RibbonFlag::EdgeFalloff, R"doc(Fade edges)doc")
        .value("INHERIT_PARENT_VELOCITY", whiteout::m3::RibbonFlag::InheritParentVelocity, R"doc(Inherit parent velocity)doc")
        .value("SMOOTH_SIZE", whiteout::m3::RibbonFlag::SmoothSize, R"doc(Smooth size)doc")
        .value("BEZIER_SMOOTH_SIZE", whiteout::m3::RibbonFlag::BezierSmoothSize, R"doc(Bezier smooth size)doc")
        .value("USE_VERTEX_ALPHA", whiteout::m3::RibbonFlag::UseVertexAlpha, R"doc(Use vertex alpha)doc")
        .value("SCALE_TIME_BY_PARENT", whiteout::m3::RibbonFlag::ScaleTimeByParent, R"doc(Scale time by parent)doc")
        .value("FORCE_CPU_SIM", whiteout::m3::RibbonFlag::ForceCPUSim, R"doc(Force CPU simulation)doc")
        .value("LOCAL_TIME", whiteout::m3::RibbonFlag::LocalTime, R"doc(Use local time)doc")
        .value("SIMULATE_INIT", whiteout::m3::RibbonFlag::SimulateInit, R"doc(Simulate on init)doc")
        .value("USE_LENGTH_AND_TIME", whiteout::m3::RibbonFlag::UseLengthAndTime, R"doc(Use length and time)doc")
        .value("ACCURATE_GPU_TANGENTS", whiteout::m3::RibbonFlag::AccurateGPUTangents, R"doc(Accurate GPU tangents)doc")
        .value("YAW_FROM_SPEED", whiteout::m3::RibbonFlag::YawFromSpeed, R"doc(Derive yaw from speed)doc")
        .value("USE_LOCATOR", whiteout::m3::RibbonFlag::UseLocator, R"doc(Use locator node)doc")
    ;

    py::enum_<whiteout::m3::RibbonAdditionalFlag>(m, "RibbonAdditionalFlag", R"doc(Ribbon emitter additional flags (RIB_.flags2, v8+))doc")
        .value("NONE", whiteout::m3::RibbonAdditionalFlag::None)
        .value("SPEED_RANDOMIZE", whiteout::m3::RibbonAdditionalFlag::SpeedRandomize, R"doc(Randomize emission speed)doc")
        .value("LIFESPAN_RANDOMIZE", whiteout::m3::RibbonAdditionalFlag::LifespanRandomize, R"doc(Randomize lifespan)doc")
        .value("MASS_RANDOMIZE", whiteout::m3::RibbonAdditionalFlag::MassRandomize, R"doc(Randomize mass)doc")
        .value("WORLD_SPACE", whiteout::m3::RibbonAdditionalFlag::WorldSpace, R"doc(World-space coordinates)doc")
    ;

    py::enum_<whiteout::m3::ProjectorFlag>(m, "ProjectorFlag", R"doc(Projector flags (PROJ.flags))doc")
        .value("NONE", whiteout::m3::ProjectorFlag::None)
        .value("STATIC", whiteout::m3::ProjectorFlag::Static, R"doc(Static position)doc")
        .value("UNKNOWN_FLAG0X2", whiteout::m3::ProjectorFlag::UnknownFlag0x2, R"doc(Unknown)doc")
        .value("UNKNOWN_FLAG0X4", whiteout::m3::ProjectorFlag::UnknownFlag0x4, R"doc(Unknown)doc")
        .value("UNKNOWN_FLAG0X8", whiteout::m3::ProjectorFlag::UnknownFlag0x8, R"doc(Unknown)doc")
    ;

    py::enum_<whiteout::m3::ForceFlag>(m, "ForceFlag", R"doc(Force flags (FOR_.flags))doc")
        .value("NONE", whiteout::m3::ForceFlag::None)
        .value("FALLOFF", whiteout::m3::ForceFlag::Falloff, R"doc(Distance falloff)doc")
        .value("HEIGHT_GRADIENT", whiteout::m3::ForceFlag::HeightGradient, R"doc(Height gradient)doc")
        .value("UNBOUNDED", whiteout::m3::ForceFlag::Unbounded, R"doc(Unbounded range)doc")
    ;

    py::enum_<whiteout::m3::RigidBodyFlag>(m, "RigidBodyFlag", R"doc(Rigid body flags (PHRB.flags))doc")
        .value("NONE", whiteout::m3::RigidBodyFlag::None)
        .value("COLLIDABLE", whiteout::m3::RigidBodyFlag::Collidable, R"doc(Can collide)doc")
        .value("WALKABLE", whiteout::m3::RigidBodyFlag::Walkable, R"doc(Walkable surface)doc")
        .value("STACKABLE", whiteout::m3::RigidBodyFlag::Stackable, R"doc(Can be stacked)doc")
        .value("SIMULATE_COLLISION", whiteout::m3::RigidBodyFlag::SimulateCollision, R"doc(Simulate collisions)doc")
        .value("IGNORE_LOCAL_BODIES", whiteout::m3::RigidBodyFlag::IgnoreLocalBodies, R"doc(Ignore local bodies)doc")
        .value("ALWAYS_EXISTS", whiteout::m3::RigidBodyFlag::AlwaysExists, R"doc(Always present)doc")
        .value("UNKNOWN6", whiteout::m3::RigidBodyFlag::Unknown6, R"doc(Unknown)doc")
        .value("NO_SIMULATION", whiteout::m3::RigidBodyFlag::NoSimulation, R"doc(Disable simulation)doc")
        .value("UNKNOWN9", whiteout::m3::RigidBodyFlag::Unknown9, R"doc(Unknown)doc")
    ;

    py::class_<whiteout::m3::Extent>(m, "Extent", R"doc(Axis-aligned bounding box with bounding sphere radius (28 bytes)

Used throughout M3 for model bounds, collision bounds, and per-region extents.)doc")
        .def(py::init<>())
        .def_readwrite("min", &whiteout::m3::Extent::min, R"doc(AABB minimum corner)doc")
        .def_readwrite("max", &whiteout::m3::Extent::max, R"doc(AABB maximum corner)doc")
        .def_readwrite("radius", &whiteout::m3::Extent::radius, R"doc(Bounding sphere radius)doc")
    ;

    py::class_<whiteout::m3::ColorBGRA>(m, "ColorBGRA", R"doc(Color stored as BGRA (4 bytes)

Blue-green-red-alpha byte order, matching the M3 on-disk format.)doc")
        .def(py::init<>())
        .def_readwrite("b", &whiteout::m3::ColorBGRA::b, R"doc(Blue channel)doc")
        .def_readwrite("g", &whiteout::m3::ColorBGRA::g, R"doc(Green channel)doc")
        .def_readwrite("r", &whiteout::m3::ColorBGRA::r, R"doc(Red channel)doc")
        .def_readwrite("a", &whiteout::m3::ColorBGRA::a, R"doc(Alpha channel)doc")
    ;

    py::class_<whiteout::m3::ColorBGR>(m, "ColorBGR")
        .def(py::init<>())
        .def_readwrite("b", &whiteout::m3::ColorBGR::b, R"doc(Blue channel)doc")
        .def_readwrite("g", &whiteout::m3::ColorBGR::g, R"doc(Green channel)doc")
        .def_readwrite("r", &whiteout::m3::ColorBGR::r, R"doc(Red channel)doc")
    ;

    py::class_<whiteout::m3::Event>(m, "Event", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::Event::name, R"doc(Event name (Ref<CHAR>))doc")
        .def_readwrite("unknown", &whiteout::m3::Event::unknown, R"doc(Unknown field)doc")
        .def_readwrite("bone_index", &whiteout::m3::Event::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("padding", &whiteout::m3::Event::padding, R"doc(Alignment padding)doc")
        .def_readwrite("event_type", &whiteout::m3::Event::eventType, R"doc(Engine-specific event type code)doc")
        .def_readwrite("option_string", &whiteout::m3::Event::optionString, R"doc(Optional parameter string (Ref<CHAR>))doc")
        .def_readwrite("rtt_channel_index", &whiteout::m3::Event::rttChannelIndex, R"doc(RTT channel index)doc")
        .def_readwrite("extra_parameter", &whiteout::m3::Event::extraParameter, R"doc(Extra parameter (v2+))doc")
    ;

    py::class_<whiteout::m3::Sequence>(m, "Sequence", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("id", &whiteout::m3::Sequence::id, R"doc(Unique sequence identifier)doc")
        .def_readwrite("index", &whiteout::m3::Sequence::index, R"doc(Sequence index)doc")
        .def_readwrite("name", &whiteout::m3::Sequence::name, R"doc(Sequence name (Ref<CHAR>))doc")
        .def_readwrite("start_frame", &whiteout::m3::Sequence::startFrame, R"doc(First frame (inclusive))doc")
        .def_readwrite("end_frame", &whiteout::m3::Sequence::endFrame, R"doc(Last frame (inclusive))doc")
        .def_readwrite("move_speed", &whiteout::m3::Sequence::moveSpeed, R"doc(Movement speed multiplier)doc")
        .def_readwrite("flags", &whiteout::m3::Sequence::flags, R"doc(Playback flags (loop, global, etc.))doc")
        .def_readwrite("frequency", &whiteout::m3::Sequence::frequency, R"doc(Selection frequency / priority weight)doc")
        .def_readwrite("replay_start", &whiteout::m3::Sequence::replayStart, R"doc(Replay region start frame)doc")
        .def_readwrite("replay_end", &whiteout::m3::Sequence::replayEnd, R"doc(Replay region end frame)doc")
        .def_readwrite("blend_time", &whiteout::m3::Sequence::blendTime, R"doc(Blend-in time (ms))doc")
        .def_readwrite("bounds", &whiteout::m3::Sequence::bounds, R"doc(Animated bounding volume)doc")
        .def_readwrite("animation_sets", &whiteout::m3::Sequence::animationSets, R"doc(Animation set indices (U8__))doc")
    ;

    py::class_<whiteout::m3::SubTrackContainer>(m, "SubTrackContainer", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::SubTrackContainer::name, R"doc(Container name (Ref<CHAR>))doc")
        .def_readwrite("runs_concurrent", &whiteout::m3::SubTrackContainer::runsConcurrent, R"doc(Non-zero if runs concurrently)doc")
        .def_readwrite("anim_priority", &whiteout::m3::SubTrackContainer::animPriority, R"doc(Animation priority level)doc")
        .def_readwrite("animation_state_index", &whiteout::m3::SubTrackContainer::animationStateIndex, R"doc(Parent STS_ index)doc")
        .def_readwrite("padding", &whiteout::m3::SubTrackContainer::padding, R"doc(Alignment padding)doc")
        .def_readwrite("anim_ids", &whiteout::m3::SubTrackContainer::animIds, R"doc(Animation IDs (U32_))doc")
        .def_readwrite("anim_refs", &whiteout::m3::SubTrackContainer::animRefs, R"doc(Animation reference indices (U32_))doc")
        .def_readwrite("unknown", &whiteout::m3::SubTrackContainer::unknown, R"doc(Unknown field)doc")
    ;

    py::class_<whiteout::m3::AnimationGroup>(m, "AnimationGroup", R"doc(STG_ — Animation group (v0, 24 bytes)

Groups sub-track containers by name for organizational purposes.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::AnimationGroup::name, R"doc(Group name (Ref<CHAR>))doc")
        .def_readwrite("subtrack_indices", &whiteout::m3::AnimationGroup::subtrackIndices, R"doc(Indices into STC_ array (U32_))doc")
    ;

    py::class_<whiteout::m3::AnimationState>(m, "AnimationState", R"doc(STS_ — Animation state (v0, 28 bytes)

Top-level animation state containing a set of animation IDs and 16 bytes of unknown state data.)doc")
        .def(py::init<>())
        .def_readwrite("anim_ids", &whiteout::m3::AnimationState::animIds, R"doc(Animation IDs (U32_))doc")
        .def("get_unknown",
            [](const whiteout::m3::AnimationState& self) {
                return std::vector<whiteout::u8>(self.unknown.begin(), self.unknown.end());
            })
        .def("set_unknown",
            [](whiteout::m3::AnimationState& self, const std::vector<whiteout::u8>& v) {
                if (v.size() != self.unknown.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.unknown.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.unknown[i] = v[i];
            })
    ;

    py::class_<whiteout::m3::BoneAnimationSet>(m, "BoneAnimationSet", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("animation_sequence_index", &whiteout::m3::BoneAnimationSet::animationSequenceIndex, R"doc(Primary sequence index)doc")
        .def_readwrite("fallback_sequence_index", &whiteout::m3::BoneAnimationSet::fallbackSequenceIndex, R"doc(Fallback sequence index)doc")
        .def_readwrite("name", &whiteout::m3::BoneAnimationSet::name, R"doc(Set name (Ref<CHAR>))doc")
        .def_readwrite("split_items", &whiteout::m3::BoneAnimationSet::splitItems, R"doc(Split item indices (U16_))doc")
    ;

    py::class_<whiteout::m3::ParticleEmitter>(m, "ParticleEmitter", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("bone_index", &whiteout::m3::ParticleEmitter::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("material_index", &whiteout::m3::ParticleEmitter::materialIndex, R"doc(Index into MATM material map array)doc")
        .def_readwrite("additional_flags", &whiteout::m3::ParticleEmitter::additionalFlags)
        .def_readwrite("initial_speed", &whiteout::m3::ParticleEmitter::initialSpeed, R"doc(Initial particle speed)doc")
        .def_readwrite("initial_speed_random", &whiteout::m3::ParticleEmitter::initialSpeedRandom, R"doc(Random speed variation)doc")
        .def_readwrite("initial_yaw", &whiteout::m3::ParticleEmitter::initialYaw, R"doc(Initial yaw angle)doc")
        .def_readwrite("initial_pitch", &whiteout::m3::ParticleEmitter::initialPitch, R"doc(Initial pitch angle)doc")
        .def_readwrite("initial_horizontal", &whiteout::m3::ParticleEmitter::initialHorizontal, R"doc(Initial horizontal spread)doc")
        .def_readwrite("initial_vertical", &whiteout::m3::ParticleEmitter::initialVertical, R"doc(Initial vertical spread)doc")
        .def_readwrite("lifetime", &whiteout::m3::ParticleEmitter::lifetime, R"doc(Base particle lifetime)doc")
        .def_readwrite("lifetime_random", &whiteout::m3::ParticleEmitter::lifetimeRandom, R"doc(Random lifetime variation)doc")
        .def_readwrite("kill_radius", &whiteout::m3::ParticleEmitter::killRadius, R"doc(Kill radius (particles beyond this are destroyed))doc")
        .def_readwrite("gravity_x", &whiteout::m3::ParticleEmitter::gravityX, R"doc(Gravity X component (expected 0))doc")
        .def_readwrite("gravity_y", &whiteout::m3::ParticleEmitter::gravityY, R"doc(Gravity Y component (expected 0))doc")
        .def_readwrite("gravity", &whiteout::m3::ParticleEmitter::gravity, R"doc(Gravity Z component)doc")
        .def_readwrite("size_mid_time", &whiteout::m3::ParticleEmitter::sizeMidTime, R"doc(Size midpoint time (0–1, v12+))doc")
        .def_readwrite("color_mid_time", &whiteout::m3::ParticleEmitter::colorMidTime, R"doc(Color midpoint time (0–1, v12+))doc")
        .def_readwrite("alpha_mid_time", &whiteout::m3::ParticleEmitter::alphaMidTime, R"doc(Alpha midpoint time (0–1, v12+))doc")
        .def_readwrite("rotation_mid_time", &whiteout::m3::ParticleEmitter::rotationMidTime, R"doc(Rotation midpoint time (0–1, v12+))doc")
        .def_readwrite("size_mid_hold_time", &whiteout::m3::ParticleEmitter::sizeMidHoldTime, R"doc(Size hold time at midpoint (v14+))doc")
        .def_readwrite("color_mid_hold_time", &whiteout::m3::ParticleEmitter::colorMidHoldTime, R"doc(Color hold time at midpoint (v14+))doc")
        .def_readwrite("alpha_mid_hold_time", &whiteout::m3::ParticleEmitter::alphaMidHoldTime, R"doc(Alpha hold time at midpoint (v14+))doc")
        .def_readwrite("rotation_mid_hold_time", &whiteout::m3::ParticleEmitter::rotationMidHoldTime, R"doc(Rotation hold time at midpoint (v14+))doc")
        .def_readwrite("size_animation", &whiteout::m3::ParticleEmitter::sizeAnimation, R"doc(Size curve (start, mid, end))doc")
        .def_readwrite("rotation_animation", &whiteout::m3::ParticleEmitter::rotationAnimation, R"doc(Rotation curve (start, mid, end))doc")
        .def_readwrite("color_start", &whiteout::m3::ParticleEmitter::colorStart, R"doc(Color at birth)doc")
        .def_readwrite("color_mid", &whiteout::m3::ParticleEmitter::colorMid, R"doc(Color at midpoint)doc")
        .def_readwrite("color_end", &whiteout::m3::ParticleEmitter::colorEnd, R"doc(Color at death)doc")
        .def_readwrite("drag", &whiteout::m3::ParticleEmitter::drag, R"doc(Air drag coefficient)doc")
        .def_readwrite("mass", &whiteout::m3::ParticleEmitter::mass, R"doc(Particle mass)doc")
        .def_readwrite("mass_random", &whiteout::m3::ParticleEmitter::massRandom, R"doc(Random mass variation multiplier)doc")
        .def_readwrite("mass_size_multiplier", &whiteout::m3::ParticleEmitter::massSizeMultiplier, R"doc(Mass–size coupling (v12+))doc")
        .def_readwrite("local_forces", &whiteout::m3::ParticleEmitter::localForces, R"doc(Local force channel bitmask)doc")
        .def_readwrite("world_forces", &whiteout::m3::ParticleEmitter::worldForces, R"doc(World force channel bitmask)doc")
        .def_readwrite("local_forces_fallback", &whiteout::m3::ParticleEmitter::localForcesFallback, R"doc(Fallback local force channels)doc")
        .def_readwrite("world_forces_fallback", &whiteout::m3::ParticleEmitter::worldForcesFallback, R"doc(Fallback world force channels)doc")
        .def_readwrite("world_forces_mass_multiplier", &whiteout::m3::ParticleEmitter::worldForcesMassMultiplier, R"doc(World force mass multiplier (v24+))doc")
        .def_readwrite("noise_amplitude", &whiteout::m3::ParticleEmitter::noiseAmplitude, R"doc(Noise displacement amplitude)doc")
        .def_readwrite("noise_frequency", &whiteout::m3::ParticleEmitter::noiseFrequency, R"doc(Noise spatial frequency)doc")
        .def_readwrite("noise_coherence", &whiteout::m3::ParticleEmitter::noiseCoherence, R"doc(Noise temporal coherence)doc")
        .def_readwrite("noise_edge", &whiteout::m3::ParticleEmitter::noiseEdge, R"doc(Noise edge sharpness)doc")
        .def_readwrite("index_plus_length", &whiteout::m3::ParticleEmitter::indexPlusLength, R"doc(Index + length (v11+))doc")
        .def_readwrite("max_particles", &whiteout::m3::ParticleEmitter::maxParticles, R"doc(Maximum live particle count)doc")
        .def_readwrite("emission_rate", &whiteout::m3::ParticleEmitter::emissionRate, R"doc(Animated emission rate (particles/sec))doc")
        .def_readwrite("emitter_shape", &whiteout::m3::ParticleEmitter::emitterShape, R"doc(Emission shape)doc")
        .def_readwrite("shape_outer", &whiteout::m3::ParticleEmitter::shapeOuter, R"doc(Animated outer shape dimensions)doc")
        .def_readwrite("shape_inner", &whiteout::m3::ParticleEmitter::shapeInner, R"doc(Animated inner shape dimensions)doc")
        .def_readwrite("outer_radius", &whiteout::m3::ParticleEmitter::outerRadius, R"doc(Animated outer radius)doc")
        .def_readwrite("inner_radius", &whiteout::m3::ParticleEmitter::innerRadius, R"doc(Animated inner radius)doc")
        .def_readwrite("shape_regions", &whiteout::m3::ParticleEmitter::shapeRegions, R"doc(Shape region indices (U32_, v14+), which mesh region from div to use)doc")
        .def_readwrite("velocity_type", &whiteout::m3::ParticleEmitter::velocityType, R"doc(Velocity randomization type)doc")
        .def_readwrite("size_random_enable", &whiteout::m3::ParticleEmitter::sizeRandomEnable, R"doc(Enable size randomization)doc")
        .def_readwrite("size_random_animation", &whiteout::m3::ParticleEmitter::sizeRandomAnimation, R"doc(Random size curve)doc")
        .def_readwrite("rotation_random_enable", &whiteout::m3::ParticleEmitter::rotationRandomEnable, R"doc(Enable rotation randomization)doc")
        .def_readwrite("rotation_random_animation", &whiteout::m3::ParticleEmitter::rotationRandomAnimation, R"doc(Random rotation curve)doc")
        .def_readwrite("color_random_enable", &whiteout::m3::ParticleEmitter::colorRandomEnable, R"doc(Enable color randomization)doc")
        .def_readwrite("color_start_random", &whiteout::m3::ParticleEmitter::colorStartRandom, R"doc(Random color at birth)doc")
        .def_readwrite("color_mid_random", &whiteout::m3::ParticleEmitter::colorMidRandom, R"doc(Random color at midpoint)doc")
        .def_readwrite("color_end_random", &whiteout::m3::ParticleEmitter::colorEndRandom, R"doc(Random color at death)doc")
        .def_readwrite("alpha_random_enable", &whiteout::m3::ParticleEmitter::alphaRandomEnable, R"doc(Enable alpha randomization)doc")
        .def_readwrite("squirt_amount", &whiteout::m3::ParticleEmitter::squirtAmount, R"doc(Animated squirt burst count)doc")
        .def_readwrite("flipbook_start_init_index", &whiteout::m3::ParticleEmitter::flipbookStartInitIndex, R"doc(Flipbook start initial frame index)doc")
        .def_readwrite("flipbook_start_stop_index", &whiteout::m3::ParticleEmitter::flipbookStartStopIndex, R"doc(Flipbook start stop frame index)doc")
        .def_readwrite("flipbook_end_init_index", &whiteout::m3::ParticleEmitter::flipbookEndInitIndex, R"doc(Flipbook end initial frame index)doc")
        .def_readwrite("flipbook_end_stop_index", &whiteout::m3::ParticleEmitter::flipbookEndStopIndex, R"doc(Flipbook end stop frame index)doc")
        .def_readwrite("flipbook_mid_time", &whiteout::m3::ParticleEmitter::flipbookMidTime, R"doc(Flipbook midpoint time (0–1))doc")
        .def_readwrite("flipbook_columns", &whiteout::m3::ParticleEmitter::flipbookColumns, R"doc(Flipbook grid columns)doc")
        .def_readwrite("flipbook_rows", &whiteout::m3::ParticleEmitter::flipbookRows, R"doc(Flipbook grid rows)doc")
        .def_readwrite("flipbook_column_fraction", &whiteout::m3::ParticleEmitter::flipbookColumnFraction, R"doc(Column fraction (v12+))doc")
        .def_readwrite("flipbook_row_fraction", &whiteout::m3::ParticleEmitter::flipbookRowFraction, R"doc(Row fraction (v12+))doc")
        .def_readwrite("bounce", &whiteout::m3::ParticleEmitter::bounce, R"doc(Bounce coefficient)doc")
        .def_readwrite("friction", &whiteout::m3::ParticleEmitter::friction, R"doc(Friction coefficient)doc")
        .def_readwrite("collision_spawn_index", &whiteout::m3::ParticleEmitter::collisionSpawnIndex, R"doc(Emitter index to spawn on collision (-1 = none))doc")
        .def_readwrite("collision_spawn_min", &whiteout::m3::ParticleEmitter::collisionSpawnMin, R"doc(Minimum spawn count on collision)doc")
        .def_readwrite("collision_spawn_max", &whiteout::m3::ParticleEmitter::collisionSpawnMax, R"doc(Maximum spawn count on collision)doc")
        .def_readwrite("collision_spawn_chance", &whiteout::m3::ParticleEmitter::collisionSpawnChance, R"doc(Spawn probability on collision)doc")
        .def_readwrite("collision_spawn_energy", &whiteout::m3::ParticleEmitter::collisionSpawnEnergy, R"doc(Spawn energy transfer)doc")
        .def_readwrite("collision_die_bounce", &whiteout::m3::ParticleEmitter::collisionDieBounce, R"doc(Die after N bounces)doc")
        .def_readwrite("instance_type", &whiteout::m3::ParticleEmitter::instanceType, R"doc(Visual type)doc")
        .def_readwrite("tail_length", &whiteout::m3::ParticleEmitter::tailLength, R"doc(Tail length for Tail/Trail types)doc")
        .def_readwrite("instance_angle", &whiteout::m3::ParticleEmitter::instanceAngle, R"doc(Instance orientation angles)doc")
        .def_readwrite("instance_distance", &whiteout::m3::ParticleEmitter::instanceDistance, R"doc(Instance distance (v17+))doc")
        .def_readwrite("pitch_type", &whiteout::m3::ParticleEmitter::pitchType, R"doc(Pitch variation type)doc")
        .def_readwrite("pitch_amplitude", &whiteout::m3::ParticleEmitter::pitchAmplitude, R"doc(Pitch variation amplitude)doc")
        .def_readwrite("pitch_frequency", &whiteout::m3::ParticleEmitter::pitchFrequency, R"doc(Pitch variation frequency)doc")
        .def_readwrite("yaw_type", &whiteout::m3::ParticleEmitter::yawType, R"doc(Yaw variation type)doc")
        .def_readwrite("yaw_amplitude", &whiteout::m3::ParticleEmitter::yawAmplitude, R"doc(Yaw variation amplitude)doc")
        .def_readwrite("yaw_frequency", &whiteout::m3::ParticleEmitter::yawFrequency, R"doc(Yaw variation frequency)doc")
        .def_readwrite("speed_type", &whiteout::m3::ParticleEmitter::speedType, R"doc(Speed variation type)doc")
        .def_readwrite("speed_amplitude", &whiteout::m3::ParticleEmitter::speedAmplitude, R"doc(Speed variation amplitude)doc")
        .def_readwrite("speed_frequency", &whiteout::m3::ParticleEmitter::speedFrequency, R"doc(Speed variation frequency)doc")
        .def_readwrite("size_type", &whiteout::m3::ParticleEmitter::sizeType, R"doc(Size variation type)doc")
        .def_readwrite("size_amplitude", &whiteout::m3::ParticleEmitter::sizeAmplitude, R"doc(Size variation amplitude)doc")
        .def_readwrite("size_frequency", &whiteout::m3::ParticleEmitter::sizeFrequency, R"doc(Size variation frequency)doc")
        .def_readwrite("alpha_type", &whiteout::m3::ParticleEmitter::alphaType, R"doc(Alpha variation type)doc")
        .def_readwrite("alpha_amplitude", &whiteout::m3::ParticleEmitter::alphaAmplitude, R"doc(Alpha variation amplitude)doc")
        .def_readwrite("alpha_frequency", &whiteout::m3::ParticleEmitter::alphaFrequency, R"doc(Alpha variation frequency)doc")
        .def_readwrite("color_type", &whiteout::m3::ParticleEmitter::colorType, R"doc(Color variation type)doc")
        .def_readwrite("color_amplitude", &whiteout::m3::ParticleEmitter::colorAmplitude, R"doc(Color variation amplitude)doc")
        .def_readwrite("color_frequency", &whiteout::m3::ParticleEmitter::colorFrequency, R"doc(Color variation frequency)doc")
        .def_readwrite("rotation_type", &whiteout::m3::ParticleEmitter::rotationType, R"doc(Rotation variation type)doc")
        .def_readwrite("rotation_amplitude", &whiteout::m3::ParticleEmitter::rotationAmplitude, R"doc(Rotation variation amplitude)doc")
        .def_readwrite("rotation_frequency", &whiteout::m3::ParticleEmitter::rotationFrequency, R"doc(Rotation variation frequency)doc")
        .def_readwrite("horizontal_type", &whiteout::m3::ParticleEmitter::horizontalType, R"doc(Horizontal variation type)doc")
        .def_readwrite("horizontal_amplitude", &whiteout::m3::ParticleEmitter::horizontalAmplitude, R"doc(Horizontal variation amplitude)doc")
        .def_readwrite("horizontal_frequency", &whiteout::m3::ParticleEmitter::horizontalFrequency, R"doc(Horizontal variation frequency)doc")
        .def_readwrite("vertical_type", &whiteout::m3::ParticleEmitter::verticalType, R"doc(Vertical variation type)doc")
        .def_readwrite("vertical_amplitude", &whiteout::m3::ParticleEmitter::verticalAmplitude, R"doc(Vertical variation amplitude)doc")
        .def_readwrite("vertical_frequency", &whiteout::m3::ParticleEmitter::verticalFrequency, R"doc(Vertical variation frequency;)doc")
        .def_readwrite("particle_velocity", &whiteout::m3::ParticleEmitter::particleVelocity, R"doc(Animated parent velocity influence)doc")
        .def_readwrite("phase_shift", &whiteout::m3::ParticleEmitter::phaseShift, R"doc(Animated phase shift (v22+))doc")
        .def_readwrite("flags", &whiteout::m3::ParticleEmitter::flags, R"doc(Main particle flags)doc")
        .def_readwrite("rotation_flags", &whiteout::m3::ParticleEmitter::rotationFlags, R"doc(Rotation flags (v18+))doc")
        .def_readwrite("color_smoothing", &whiteout::m3::ParticleEmitter::colorSmoothing, R"doc(Color interpolation mode)doc")
        .def_readwrite("size_smoothing", &whiteout::m3::ParticleEmitter::sizeSmoothing, R"doc(Size interpolation mode)doc")
        .def_readwrite("rotation_smoothing", &whiteout::m3::ParticleEmitter::rotationSmoothing)
        .def_readwrite("alpha_threshold", &whiteout::m3::ParticleEmitter::alphaThreshold, R"doc(Animated alpha threshold)doc")
        .def_readwrite("uv_offset", &whiteout::m3::ParticleEmitter::uvOffset, R"doc(Animated UV offset)doc")
        .def_readwrite("uv_angle", &whiteout::m3::ParticleEmitter::uvAngle, R"doc(Animated UV rotation angles)doc")
        .def_readwrite("uv_tiling", &whiteout::m3::ParticleEmitter::uvTiling, R"doc(Animated UV tiling)doc")
        .def_readwrite("spline_line_data", &whiteout::m3::ParticleEmitter::splineLineData, R"doc(Spline control points (SVC3))doc")
        .def_readwrite("wind_multiplier", &whiteout::m3::ParticleEmitter::windMultiplier, R"doc(Wind influence multiplier)doc")
        .def_readwrite("lod_reduce", &whiteout::m3::ParticleEmitter::lodReduce, R"doc(LOD reduction level)doc")
        .def_readwrite("lod_cut", &whiteout::m3::ParticleEmitter::lodCut, R"doc(LOD cut-off level)doc")
        .def_readwrite("lower_bound", &whiteout::m3::ParticleEmitter::lowerBound, R"doc(Animated lower bound)doc")
        .def_readwrite("upper_bound", &whiteout::m3::ParticleEmitter::upperBound, R"doc(Animated upper bound)doc")
        .def_readwrite("trail_link_index", &whiteout::m3::ParticleEmitter::trailLinkIndex)
        .def_readwrite("trail_chance", &whiteout::m3::ParticleEmitter::trailChance, R"doc(Trail spawn probability)doc")
        .def_readwrite("trail_emission_rate", &whiteout::m3::ParticleEmitter::trailEmissionRate, R"doc(Animated trail emission rate)doc")
        .def_readwrite("splat_projection_index", &whiteout::m3::ParticleEmitter::splatProjectionIndex, R"doc(Linked projector index (-1 = none))doc")
        .def_readwrite("splat_chance", &whiteout::m3::ParticleEmitter::splatChance, R"doc(Splat spawn probability)doc")
        .def_readwrite("model_paths", &whiteout::m3::ParticleEmitter::modelPaths, R"doc(Model particle paths (SCHR))doc")
        .def_readwrite("copy_indices", &whiteout::m3::ParticleEmitter::copyIndices, R"doc(Emitter copy indices (U32_))doc")
        .def_readwrite("spawn_ribbon_on_bounce_chance", &whiteout::m3::ParticleEmitter::spawnRibbonOnBounceChance, R"doc(Ribbon spawn probability on bounce (v23+))doc")
        .def_readwrite("ribbon_link_index", &whiteout::m3::ParticleEmitter::ribbonLinkIndex, R"doc(Index into RIB_ array (-1 = none, v23+))doc")
    ;

    py::class_<whiteout::m3::ParticleEmitterCopy>(m, "ParticleEmitterCopy", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("emission_rate", &whiteout::m3::ParticleEmitterCopy::emissionRate, R"doc(Overridden emission rate)doc")
        .def_readwrite("squirt_amount", &whiteout::m3::ParticleEmitterCopy::squirtAmount, R"doc(Overridden squirt burst count)doc")
        .def_readwrite("bone_index", &whiteout::m3::ParticleEmitterCopy::boneIndex, R"doc(Index into BONE array)doc")
    ;

    py::class_<whiteout::m3::SplineRibbon>(m, "SplineRibbon", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("emission_offset", &whiteout::m3::SplineRibbon::emissionOffset, R"doc(Emission point offset from bone)doc")
        .def_readwrite("emission_vector", &whiteout::m3::SplineRibbon::emissionVector, R"doc(Emission direction vector)doc")
        .def_readwrite("velocity", &whiteout::m3::SplineRibbon::velocity, R"doc(Animated base velocity)doc")
        .def_readwrite("reserved", &whiteout::m3::SplineRibbon::reserved, R"doc(Reserved (always 0))doc")
        .def_readwrite("bone_index", &whiteout::m3::SplineRibbon::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("velocity_base_factor", &whiteout::m3::SplineRibbon::velocityBaseFactor, R"doc(Animated base velocity factor)doc")
        .def_readwrite("velocity_end_factor", &whiteout::m3::SplineRibbon::velocityEndFactor, R"doc(Animated end velocity factor)doc")
        .def_readwrite("yaw_type", &whiteout::m3::SplineRibbon::yawType, R"doc(Yaw variation type)doc")
        .def_readwrite("yaw_amplitude", &whiteout::m3::SplineRibbon::yawAmplitude, R"doc(Yaw variation amplitude)doc")
        .def_readwrite("yaw_frequency", &whiteout::m3::SplineRibbon::yawFrequency, R"doc(Yaw variation frequency)doc")
        .def_readwrite("pitch_type", &whiteout::m3::SplineRibbon::pitchType, R"doc(Pitch variation type)doc")
        .def_readwrite("pitch_amplitude", &whiteout::m3::SplineRibbon::pitchAmplitude, R"doc(Pitch variation amplitude)doc")
        .def_readwrite("pitch_frequency", &whiteout::m3::SplineRibbon::pitchFrequency, R"doc(Pitch variation frequency)doc")
        .def_readwrite("velocity_type", &whiteout::m3::SplineRibbon::velocityType, R"doc(Velocity variation type)doc")
        .def_readwrite("velocity_amplitude", &whiteout::m3::SplineRibbon::velocityAmplitude, R"doc(Velocity variation amplitude)doc")
        .def_readwrite("velocity_frequency", &whiteout::m3::SplineRibbon::velocityFrequency, R"doc(Velocity variation frequency)doc")
        .def_readwrite("yaw", &whiteout::m3::SplineRibbon::yaw, R"doc(Animated yaw angle)doc")
        .def_readwrite("pitch", &whiteout::m3::SplineRibbon::pitch, R"doc(Animated pitch angle)doc")
        .def_readwrite("emission_vector_norm_factor", &whiteout::m3::SplineRibbon::emissionVectorNormFactor, R"doc(Precomputed ≈ 0.01 / |emissionVector|)doc")
        .def_readwrite("velocity_norm_factor", &whiteout::m3::SplineRibbon::velocityNormFactor, R"doc(Precomputed ≈ 0.01 / velocity.initValue)doc")
    ;

    py::class_<whiteout::m3::RibbonEmitter>(m, "RibbonEmitter", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("bone_index", &whiteout::m3::RibbonEmitter::boneIndex, R"doc(Primary bone index)doc")
        .def_readwrite("bone_index_fallback", &whiteout::m3::RibbonEmitter::boneIndexFallback, R"doc(Fallback bone index)doc")
        .def_readwrite("material_index", &whiteout::m3::RibbonEmitter::materialIndex, R"doc(Index into MATM material map array)doc")
        .def_readwrite("additional_flags", &whiteout::m3::RibbonEmitter::additionalFlags, R"doc(Additional flags (v8+))doc")
        .def_readwrite("initial_speed", &whiteout::m3::RibbonEmitter::initialSpeed, R"doc(Initial ribbon segment speed)doc")
        .def_readwrite("initial_speed_random", &whiteout::m3::RibbonEmitter::initialSpeedRandom, R"doc(Random speed variation)doc")
        .def_readwrite("initial_yaw", &whiteout::m3::RibbonEmitter::initialYaw, R"doc(Initial yaw angle)doc")
        .def_readwrite("initial_pitch", &whiteout::m3::RibbonEmitter::initialPitch, R"doc(Initial pitch angle)doc")
        .def_readwrite("initial_horizontal", &whiteout::m3::RibbonEmitter::initialHorizontal, R"doc(Initial horizontal spread)doc")
        .def_readwrite("initial_vertical", &whiteout::m3::RibbonEmitter::initialVertical, R"doc(Initial vertical spread)doc")
        .def_readwrite("lifetime", &whiteout::m3::RibbonEmitter::lifetime, R"doc(Base segment lifetime)doc")
        .def_readwrite("lifetime_random", &whiteout::m3::RibbonEmitter::lifetimeRandom, R"doc(Random lifetime variation)doc")
        .def_readwrite("kill_radius", &whiteout::m3::RibbonEmitter::killRadius, R"doc(Kill radius)doc")
        .def_readwrite("gravity_x", &whiteout::m3::RibbonEmitter::gravityX, R"doc(Gravity X component)doc")
        .def_readwrite("gravity_y", &whiteout::m3::RibbonEmitter::gravityY, R"doc(Gravity Y component)doc")
        .def_readwrite("gravity", &whiteout::m3::RibbonEmitter::gravity, R"doc(Gravity Z component)doc")
        .def_readwrite("size_mid_time", &whiteout::m3::RibbonEmitter::sizeMidTime, R"doc(Size midpoint time (0–1))doc")
        .def_readwrite("color_mid_time", &whiteout::m3::RibbonEmitter::colorMidTime, R"doc(Color midpoint time (0–1))doc")
        .def_readwrite("alpha_mid_time", &whiteout::m3::RibbonEmitter::alphaMidTime, R"doc(Alpha midpoint time (0–1))doc")
        .def_readwrite("rotation_mid_time", &whiteout::m3::RibbonEmitter::rotationMidTime, R"doc(Rotation midpoint time (0–1))doc")
        .def_readwrite("size_mid_hold_time", &whiteout::m3::RibbonEmitter::sizeMidHoldTime, R"doc(Size hold time at midpoint)doc")
        .def_readwrite("color_mid_hold_time", &whiteout::m3::RibbonEmitter::colorMidHoldTime, R"doc(Color hold time at midpoint)doc")
        .def_readwrite("alpha_mid_hold_time", &whiteout::m3::RibbonEmitter::alphaMidHoldTime, R"doc(Alpha hold time at midpoint)doc")
        .def_readwrite("rotation_mid_hold_time", &whiteout::m3::RibbonEmitter::rotationMidHoldTime, R"doc(Rotation hold time at midpoint)doc")
        .def_readwrite("size_animation", &whiteout::m3::RibbonEmitter::sizeAnimation, R"doc(Size curve (start, mid, end))doc")
        .def_readwrite("rotation_animation", &whiteout::m3::RibbonEmitter::rotationAnimation, R"doc(Rotation curve (start, mid, end))doc")
        .def_readwrite("color_start", &whiteout::m3::RibbonEmitter::colorStart, R"doc(Color at birth)doc")
        .def_readwrite("color_mid", &whiteout::m3::RibbonEmitter::colorMid, R"doc(Color at midpoint)doc")
        .def_readwrite("color_end", &whiteout::m3::RibbonEmitter::colorEnd, R"doc(Color at death)doc")
        .def_readwrite("drag", &whiteout::m3::RibbonEmitter::drag, R"doc(Air drag coefficient)doc")
        .def_readwrite("mass", &whiteout::m3::RibbonEmitter::mass, R"doc(Segment mass)doc")
        .def_readwrite("mass_random", &whiteout::m3::RibbonEmitter::massRandom, R"doc(Random mass variation)doc")
        .def_readwrite("mass_size_multiplier", &whiteout::m3::RibbonEmitter::massSizeMultiplier, R"doc(Mass–size coupling)doc")
        .def_readwrite("local_forces", &whiteout::m3::RibbonEmitter::localForces, R"doc(Local force channel bitmask)doc")
        .def_readwrite("world_forces", &whiteout::m3::RibbonEmitter::worldForces, R"doc(World force channel bitmask)doc")
        .def_readwrite("local_forces_fallback", &whiteout::m3::RibbonEmitter::localForcesFallback, R"doc(Fallback local force channels)doc")
        .def_readwrite("world_forces_fallback", &whiteout::m3::RibbonEmitter::worldForcesFallback, R"doc(Fallback world force channels)doc")
        .def_readwrite("world_forces_mass_multiplier", &whiteout::m3::RibbonEmitter::worldForcesMassMultiplier, R"doc(World force mass multiplier)doc")
        .def_readwrite("noise_amplitude", &whiteout::m3::RibbonEmitter::noiseAmplitude, R"doc(Noise displacement amplitude)doc")
        .def_readwrite("noise_frequency", &whiteout::m3::RibbonEmitter::noiseFrequency, R"doc(Noise spatial frequency)doc")
        .def_readwrite("noise_coherence", &whiteout::m3::RibbonEmitter::noiseCoherence, R"doc(Noise temporal coherence)doc")
        .def_readwrite("noise_edge", &whiteout::m3::RibbonEmitter::noiseEdge, R"doc(Noise edge sharpness)doc")
        .def_readwrite("index_plus_length", &whiteout::m3::RibbonEmitter::indexPlusLength, R"doc(Index + length)doc")
        .def_readwrite("emitter_shape", &whiteout::m3::RibbonEmitter::emitterShape, R"doc(Emitter shape type)doc")
        .def_readwrite("ribbon_type", &whiteout::m3::RibbonEmitter::ribbonType, R"doc(Ribbon cross-section type)doc")
        .def_readwrite("divisions", &whiteout::m3::RibbonEmitter::divisions, R"doc(Number of ribbon divisions)doc")
        .def_readwrite("edges", &whiteout::m3::RibbonEmitter::edges, R"doc(Number of cross-section edges)doc")
        .def_readwrite("inner_radius", &whiteout::m3::RibbonEmitter::innerRadius, R"doc(Inner radius)doc")
        .def_readwrite("max_length", &whiteout::m3::RibbonEmitter::maxLength, R"doc(Animated maximum ribbon length)doc")
        .def_readwrite("spline_ribbons", &whiteout::m3::RibbonEmitter::splineRibbons, R"doc(Spline ribbon segments (SRIB))doc")
        .def_readwrite("active", &whiteout::m3::RibbonEmitter::active, R"doc(Animated active state)doc")
        .def_readwrite("flags", &whiteout::m3::RibbonEmitter::flags, R"doc(Ribbon emitter flags)doc")
        .def_readwrite("size_smoothing", &whiteout::m3::RibbonEmitter::sizeSmoothing, R"doc(Size interpolation mode)doc")
        .def_readwrite("color_smoothing", &whiteout::m3::RibbonEmitter::colorSmoothing, R"doc(Color interpolation mode)doc")
        .def_readwrite("friction", &whiteout::m3::RibbonEmitter::friction, R"doc(Friction coefficient)doc")
        .def_readwrite("bounce", &whiteout::m3::RibbonEmitter::bounce, R"doc(Bounce coefficient)doc")
        .def_readwrite("lod_reduce", &whiteout::m3::RibbonEmitter::lodReduce, R"doc(LOD reduction level)doc")
        .def_readwrite("lod_cut", &whiteout::m3::RibbonEmitter::lodCut, R"doc(LOD cut-off level)doc")
        .def_readwrite("yaw_type", &whiteout::m3::RibbonEmitter::yawType, R"doc(Yaw variation type)doc")
        .def_readwrite("yaw_amplitude", &whiteout::m3::RibbonEmitter::yawAmplitude, R"doc(Yaw variation amplitude)doc")
        .def_readwrite("yaw_frequency", &whiteout::m3::RibbonEmitter::yawFrequency, R"doc(Yaw variation frequency)doc")
        .def_readwrite("pitch_type", &whiteout::m3::RibbonEmitter::pitchType, R"doc(Pitch variation type)doc")
        .def_readwrite("pitch_amplitude", &whiteout::m3::RibbonEmitter::pitchAmplitude, R"doc(Pitch variation amplitude)doc")
        .def_readwrite("pitch_frequency", &whiteout::m3::RibbonEmitter::pitchFrequency, R"doc(Pitch variation frequency)doc")
        .def_readwrite("speed_type", &whiteout::m3::RibbonEmitter::speedType, R"doc(Speed variation type)doc")
        .def_readwrite("speed_amplitude", &whiteout::m3::RibbonEmitter::speedAmplitude, R"doc(Speed variation amplitude)doc")
        .def_readwrite("speed_frequency", &whiteout::m3::RibbonEmitter::speedFrequency, R"doc(Speed variation frequency)doc")
        .def_readwrite("size_type", &whiteout::m3::RibbonEmitter::sizeType, R"doc(Size variation type)doc")
        .def_readwrite("size_amplitude", &whiteout::m3::RibbonEmitter::sizeAmplitude, R"doc(Size variation amplitude)doc")
        .def_readwrite("size_frequency", &whiteout::m3::RibbonEmitter::sizeFrequency, R"doc(Size variation frequency)doc")
        .def_readwrite("alpha_type", &whiteout::m3::RibbonEmitter::alphaType, R"doc(Alpha variation type)doc")
        .def_readwrite("alpha_amplitude", &whiteout::m3::RibbonEmitter::alphaAmplitude, R"doc(Alpha variation amplitude)doc")
        .def_readwrite("alpha_frequency", &whiteout::m3::RibbonEmitter::alphaFrequency, R"doc(Alpha variation frequency)doc")
        .def_readwrite("particle_velocity", &whiteout::m3::RibbonEmitter::particleVelocity, R"doc(Animated parent velocity influence)doc")
        .def_readwrite("overlay", &whiteout::m3::RibbonEmitter::overlay, R"doc(Animated overlay effect)doc")
    ;

    py::class_<whiteout::m3::Projector>(m, "Projector", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("projection_type", &whiteout::m3::Projector::projectionType, R"doc(Projection type (ortho/perspective))doc")
        .def_readwrite("bone", &whiteout::m3::Projector::bone, R"doc(Index into BONE array)doc")
        .def_readwrite("material_reference_index", &whiteout::m3::Projector::materialReferenceIndex, R"doc(Index into MATM material map)doc")
        .def_readwrite("offset", &whiteout::m3::Projector::offset, R"doc(Animated position offset)doc")
        .def_readwrite("pitch", &whiteout::m3::Projector::pitch, R"doc(Animated pitch angle)doc")
        .def_readwrite("yaw", &whiteout::m3::Projector::yaw, R"doc(Animated yaw angle)doc")
        .def_readwrite("roll", &whiteout::m3::Projector::roll, R"doc(Animated roll angle)doc")
        .def_readwrite("field_of_view", &whiteout::m3::Projector::fieldOfView, R"doc(Animated field of view)doc")
        .def_readwrite("aspect_ratio", &whiteout::m3::Projector::aspectRatio, R"doc(Animated aspect ratio)doc")
        .def_readwrite("near", &whiteout::m3::Projector::near, R"doc(Animated near clip plane)doc")
        .def_readwrite("far", &whiteout::m3::Projector::far, R"doc(Animated far clip plane)doc")
        .def_readwrite("box_offset_z_bottom", &whiteout::m3::Projector::boxOffsetZBottom, R"doc(Animated box Z bottom offset)doc")
        .def_readwrite("box_offset_z_top", &whiteout::m3::Projector::boxOffsetZTop, R"doc(Animated box Z top offset)doc")
        .def_readwrite("box_offset_x_left", &whiteout::m3::Projector::boxOffsetXLeft, R"doc(Animated box X left offset)doc")
        .def_readwrite("box_offset_x_right", &whiteout::m3::Projector::boxOffsetXRight, R"doc(Animated box X right offset)doc")
        .def_readwrite("box_offset_y_front", &whiteout::m3::Projector::boxOffsetYFront, R"doc(Animated box Y front offset)doc")
        .def_readwrite("box_offset_y_back", &whiteout::m3::Projector::boxOffsetYBack, R"doc(Animated box Y back offset)doc")
        .def_readwrite("falloff", &whiteout::m3::Projector::falloff, R"doc(Projection falloff distance)doc")
        .def_readwrite("alpha_init", &whiteout::m3::Projector::alphaInit, R"doc(Alpha at creation)doc")
        .def_readwrite("alpha_mid", &whiteout::m3::Projector::alphaMid, R"doc(Alpha at midpoint)doc")
        .def_readwrite("alpha_end", &whiteout::m3::Projector::alphaEnd, R"doc(Alpha at end)doc")
        .def_readwrite("lifetime_attack", &whiteout::m3::Projector::lifetimeAttack, R"doc(Attack phase duration)doc")
        .def_readwrite("lifetime_attack_to", &whiteout::m3::Projector::lifetimeAttackTo, R"doc(Attack target time)doc")
        .def_readwrite("lifetime_hold", &whiteout::m3::Projector::lifetimeHold, R"doc(Hold phase duration)doc")
        .def_readwrite("lifetime_hold_to", &whiteout::m3::Projector::lifetimeHoldTo, R"doc(Hold target time)doc")
        .def_readwrite("lifetime_decay", &whiteout::m3::Projector::lifetimeDecay, R"doc(Decay phase duration)doc")
        .def_readwrite("lifetime_decay_to", &whiteout::m3::Projector::lifetimeDecayTo, R"doc(Decay target time)doc")
        .def_readwrite("attenuation_distance", &whiteout::m3::Projector::attenuationDistance, R"doc(Distance-based attenuation)doc")
        .def_readwrite("active", &whiteout::m3::Projector::active, R"doc(Animated active state)doc")
        .def_readwrite("layer", &whiteout::m3::Projector::layer, R"doc(Render layer)doc")
        .def_readwrite("lod_reduce", &whiteout::m3::Projector::lodReduce, R"doc(LOD reduction level)doc")
        .def_readwrite("lod_cut", &whiteout::m3::Projector::lodCut, R"doc(LOD cut-off level)doc")
        .def_readwrite("flags", &whiteout::m3::Projector::flags, R"doc(Projector flags)doc")
    ;

    py::class_<whiteout::m3::MaterialMap>(m, "MaterialMap", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("material_type", &whiteout::m3::MaterialMap::materialType, R"doc(Material type (1=standard, 2=displacement, etc.))doc")
        .def_readwrite("material_index", &whiteout::m3::MaterialMap::materialIndex, R"doc(Index into the typed material array)doc")
    ;

    py::class_<whiteout::m3::TextureLayer>(m, "TextureLayer", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("id", &whiteout::m3::TextureLayer::id, R"doc(Layer identifier)doc")
        .def_readwrite("texture_path", &whiteout::m3::TextureLayer::texturePath, R"doc(Texture file path (Ref<CHAR>))doc")
        .def_readwrite("color", &whiteout::m3::TextureLayer::color, R"doc(Animated color tint)doc")
        .def_readwrite("flags", &whiteout::m3::TextureLayer::flags, R"doc(Layer flags (wrap, flipbook, video, etc.))doc")
        .def_readwrite("uv_mapping", &whiteout::m3::TextureLayer::uvMapping, R"doc(UV mapping source)doc")
        .def_readwrite("color_type", &whiteout::m3::TextureLayer::colorType, R"doc(Channel selection)doc")
        .def_readwrite("rgb_multiply", &whiteout::m3::TextureLayer::rgbMultiply, R"doc(RGB multiply factor)doc")
        .def_readwrite("rgb_add", &whiteout::m3::TextureLayer::rgbAdd, R"doc(RGB additive factor)doc")
        .def_readwrite("poc_texture", &whiteout::m3::TextureLayer::pocTexture, R"doc(POC texture reference)doc")
        .def_readwrite("noise_amplitude", &whiteout::m3::TextureLayer::noiseAmplitude, R"doc(Noise amplitude (v24+))doc")
        .def_readwrite("noise_frequency", &whiteout::m3::TextureLayer::noiseFrequency, R"doc(Noise frequency (v24+))doc")
        .def_readwrite("texture_source", &whiteout::m3::TextureLayer::textureSource, R"doc(Texture source override)doc")
        .def_readwrite("avi_frame_rate", &whiteout::m3::TextureLayer::aviFrameRate, R"doc(AVI playback frame rate)doc")
        .def_readwrite("avi_start", &whiteout::m3::TextureLayer::aviStart, R"doc(AVI start frame)doc")
        .def_readwrite("avi_stop", &whiteout::m3::TextureLayer::aviStop, R"doc(AVI stop frame)doc")
        .def_readwrite("avi_loop", &whiteout::m3::TextureLayer::aviLoop, R"doc(AVI loop mode)doc")
        .def_readwrite("avi_sync", &whiteout::m3::TextureLayer::aviSync, R"doc(AVI sync mode)doc")
        .def_readwrite("avi_play", &whiteout::m3::TextureLayer::aviPlay, R"doc(AVI play control)doc")
        .def_readwrite("avi_restart", &whiteout::m3::TextureLayer::aviRestart, R"doc(AVI restart control)doc")
        .def_readwrite("flipbook_rows", &whiteout::m3::TextureLayer::flipbookRows, R"doc(Flipbook grid rows)doc")
        .def_readwrite("flipbook_columns", &whiteout::m3::TextureLayer::flipbookColumns, R"doc(Flipbook grid columns)doc")
        .def_readwrite("current_frame", &whiteout::m3::TextureLayer::currentFrame, R"doc(Animated flipbook frame index)doc")
        .def_readwrite("uv_offset", &whiteout::m3::TextureLayer::uvOffset, R"doc(Animated UV offset)doc")
        .def_readwrite("uv_angle", &whiteout::m3::TextureLayer::uvAngle, R"doc(Animated UV rotation angles)doc")
        .def_readwrite("uv_tiling", &whiteout::m3::TextureLayer::uvTiling, R"doc(Animated UV tiling)doc")
        .def_readwrite("w_offset", &whiteout::m3::TextureLayer::wOffset, R"doc(Animated W offset (3D textures))doc")
        .def_readwrite("w_tiling", &whiteout::m3::TextureLayer::wTiling, R"doc(Animated W tiling (3D textures))doc")
        .def_readwrite("map_alpha", &whiteout::m3::TextureLayer::mapAlpha, R"doc(Animated map alpha)doc")
        .def_readwrite("triplanar_offset", &whiteout::m3::TextureLayer::triplanarOffset, R"doc(Tri-planar UV offset (v23+))doc")
        .def_readwrite("triplanar_scale", &whiteout::m3::TextureLayer::triplanarScale, R"doc(Tri-planar UV scale (v23+))doc")
        .def_readwrite("uv_source_related", &whiteout::m3::TextureLayer::uvSourceRelated, R"doc(UV source related field)doc")
        .def_readwrite("fresnel_mode", &whiteout::m3::TextureLayer::fresnelMode, R"doc(Fresnel effect mode)doc")
        .def_readwrite("fresnel_exponent", &whiteout::m3::TextureLayer::fresnelExponent, R"doc(Fresnel exponent (edge sharpness))doc")
        .def_readwrite("fresnel_min", &whiteout::m3::TextureLayer::fresnelMin, R"doc(Fresnel minimum intensity)doc")
        .def_readwrite("fresnel_max", &whiteout::m3::TextureLayer::fresnelMax, R"doc(Fresnel maximum intensity)doc")
        .def_readwrite("fresnel_translation", &whiteout::m3::TextureLayer::fresnelTranslation, R"doc(Fresnel UV translation (v25+))doc")
        .def_readwrite("fresnel_mask", &whiteout::m3::TextureLayer::fresnelMask, R"doc(Fresnel mask vector (v25+))doc")
        .def_readwrite("fresnel_rotation", &whiteout::m3::TextureLayer::fresnelRotation, R"doc(Fresnel UV rotation (v25+))doc")
        .def_readwrite("uv_density", &whiteout::m3::TextureLayer::uvDensity, R"doc(UV density hint (v0–v25, absent in v26))doc")
    ;

    py::class_<whiteout::m3::StandardMaterial>(m, "StandardMaterial", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::StandardMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("additional_flags", &whiteout::m3::StandardMaterial::additionalFlags, R"doc(Additional flags)doc")
        .def_readwrite("flags", &whiteout::m3::StandardMaterial::flags, R"doc(Material rendering flags)doc")
        .def_readwrite("blend_mode", &whiteout::m3::StandardMaterial::blendMode, R"doc(Alpha blend mode)doc")
        .def_readwrite("priority", &whiteout::m3::StandardMaterial::priority, R"doc(Render priority (lower = earlier))doc")
        .def_readwrite("rtt_channels", &whiteout::m3::StandardMaterial::rttChannels, R"doc(RTT channel mask)doc")
        .def_readwrite("specular_exponent", &whiteout::m3::StandardMaterial::specularExponent, R"doc(Specular highlight exponent)doc")
        .def_readwrite("depth_blend_falloff", &whiteout::m3::StandardMaterial::depthBlendFalloff, R"doc(Depth blend falloff distance)doc")
        .def_readwrite("alpha_test_threshold", &whiteout::m3::StandardMaterial::alphaTestThreshold, R"doc(Alpha test cut-off value)doc")
        .def_readwrite("hdr_specular_multiplier", &whiteout::m3::StandardMaterial::hdrSpecularMultiplier, R"doc(HDR specular multiplier)doc")
        .def_readwrite("hdr_emissive_multiplier", &whiteout::m3::StandardMaterial::hdrEmissiveMultiplier, R"doc(HDR emissive multiplier)doc")
        .def_readwrite("hdr_environment_constant", &whiteout::m3::StandardMaterial::hdrEnvironmentConstant, R"doc(HDR environment constant (v20))doc")
        .def_readwrite("hdr_environment_diffuse", &whiteout::m3::StandardMaterial::hdrEnvironmentDiffuse, R"doc(HDR environment diffuse (v20))doc")
        .def_readwrite("hdr_environment_specular", &whiteout::m3::StandardMaterial::hdrEnvironmentSpecular, R"doc(HDR environment specular (v20))doc")
        .def_readwrite("diffuse_layer", &whiteout::m3::StandardMaterial::diffuseLayer, R"doc(Diffuse / albedo texture)doc")
        .def_readwrite("decal_layer", &whiteout::m3::StandardMaterial::decalLayer, R"doc(Decal overlay texture)doc")
        .def_readwrite("specular_layer", &whiteout::m3::StandardMaterial::specularLayer, R"doc(Specular map texture)doc")
        .def_readwrite("gloss_layer", &whiteout::m3::StandardMaterial::glossLayer, R"doc(Gloss map texture (v16+))doc")
        .def_readwrite("emissive_layer1", &whiteout::m3::StandardMaterial::emissiveLayer1, R"doc(Emissive layer 1)doc")
        .def_readwrite("emissive_layer2", &whiteout::m3::StandardMaterial::emissiveLayer2, R"doc(Emissive layer 2)doc")
        .def_readwrite("environment_layer", &whiteout::m3::StandardMaterial::environmentLayer, R"doc(Environment reflection map)doc")
        .def_readwrite("environment_mask_layer", &whiteout::m3::StandardMaterial::environmentMaskLayer, R"doc(Environment mask)doc")
        .def_readwrite("alpha_layer1", &whiteout::m3::StandardMaterial::alphaLayer1, R"doc(Alpha mask layer 1)doc")
        .def_readwrite("alpha_layer2", &whiteout::m3::StandardMaterial::alphaLayer2, R"doc(Alpha mask layer 2)doc")
        .def_readwrite("normal_layer", &whiteout::m3::StandardMaterial::normalLayer, R"doc(Normal / bump map)doc")
        .def_readwrite("height_layer", &whiteout::m3::StandardMaterial::heightLayer, R"doc(Height / parallax map)doc")
        .def_readwrite("light_map_layer", &whiteout::m3::StandardMaterial::lightMapLayer, R"doc(Light map)doc")
        .def_readwrite("ambient_occlusion_layer", &whiteout::m3::StandardMaterial::ambientOcclusionLayer, R"doc(Ambient occlusion map)doc")
        .def_readwrite("normal_blend1_mask_layer", &whiteout::m3::StandardMaterial::normalBlend1MaskLayer, R"doc(Normal blend 1 mask (v19+))doc")
        .def_readwrite("normal_blend2_mask_layer", &whiteout::m3::StandardMaterial::normalBlend2MaskLayer, R"doc(Normal blend 2 mask (v19+))doc")
        .def_readwrite("normal_blend1_layer", &whiteout::m3::StandardMaterial::normalBlend1Layer, R"doc(Normal blend 1 map (v19+))doc")
        .def_readwrite("normal_blend2_layer", &whiteout::m3::StandardMaterial::normalBlend2Layer, R"doc(Normal blend 2 map (v19+))doc")
        .def_readwrite("material_class", &whiteout::m3::StandardMaterial::materialClass, R"doc(Material class (unit, building, etc.))doc")
        .def_readwrite("layer_blend_mode", &whiteout::m3::StandardMaterial::layerBlendMode, R"doc(Layer blend operation)doc")
        .def_readwrite("emissive_blend_mode1", &whiteout::m3::StandardMaterial::emissiveBlendMode1, R"doc(Emissive layer 1 blend mode)doc")
        .def_readwrite("emissive_blend_mode2", &whiteout::m3::StandardMaterial::emissiveBlendMode2, R"doc(Emissive layer 2 blend mode)doc")
        .def_readwrite("specular_mode", &whiteout::m3::StandardMaterial::specularMode, R"doc(Specular computation mode)doc")
        .def_readwrite("parallax_height", &whiteout::m3::StandardMaterial::parallaxHeight, R"doc(Animated parallax height)doc")
        .def_readwrite("motion_blur_amount", &whiteout::m3::StandardMaterial::motionBlurAmount, R"doc(Animated motion blur amount)doc")
        .def_readwrite("normal_blend_factors", &whiteout::m3::StandardMaterial::normalBlendFactors, R"doc(Normal blend factors (v19+))doc")
    ;

    py::class_<whiteout::m3::DisplacementMaterial>(m, "DisplacementMaterial", R"doc(DIS_ — Displacement material (v0–v4, 68 bytes)

Applies vertex displacement via a normal map and animated strength.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::DisplacementMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("unknown", &whiteout::m3::DisplacementMaterial::unknown, R"doc(Unknown field)doc")
        .def_readwrite("strength", &whiteout::m3::DisplacementMaterial::strength, R"doc(Animated displacement strength)doc")
        .def_readwrite("normal_map", &whiteout::m3::DisplacementMaterial::normalMap, R"doc(Normal / displacement direction map)doc")
        .def_readwrite("strength_map", &whiteout::m3::DisplacementMaterial::strengthMap, R"doc(Strength mask texture)doc")
        .def_readwrite("priority", &whiteout::m3::DisplacementMaterial::priority, R"doc(Render priority)doc")
    ;

    py::class_<whiteout::m3::CompositeSection>(m, "CompositeSection", R"doc(CMS_ — Composite material section (v0, 24 bytes)

A single section within a composite material, referencing another material index with an animated blend multiplier.)doc")
        .def(py::init<>())
        .def_readwrite("material_index", &whiteout::m3::CompositeSection::materialIndex, R"doc(Index into MATM array)doc")
        .def_readwrite("map_multiplier", &whiteout::m3::CompositeSection::mapMultiplier, R"doc(Animated blend weight)doc")
    ;

    py::class_<whiteout::m3::CompositeMaterial>(m, "CompositeMaterial", R"doc(CMP_ — Composite material (v0–v2, 28 bytes)

Blends multiple sub-materials via CompositeSection entries.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::CompositeMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("priority", &whiteout::m3::CompositeMaterial::priority, R"doc(Render priority)doc")
        .def_readwrite("sections", &whiteout::m3::CompositeMaterial::sections, R"doc(Sub-material sections (CMS_))doc")
    ;

    py::class_<whiteout::m3::TerrainMaterial>(m, "TerrainMaterial", R"doc(TER_ — Terrain material (v0–v1, 28 bytes)

Simple terrain-specific material with a single texture layer.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::TerrainMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("terrain_map", &whiteout::m3::TerrainMaterial::terrainMap, R"doc(Terrain texture layer)doc")
        .def_readwrite("unknown", &whiteout::m3::TerrainMaterial::unknown, R"doc(Unknown field)doc")
    ;

    py::class_<whiteout::m3::VolumeMaterial>(m, "VolumeMaterial", R"doc(VOL_ — Volume material (v0, 84 bytes)

Volumetric rendering material with density falloff, color map, and two noise maps for procedural volumetric effects.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::VolumeMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("blend_mode", &whiteout::m3::VolumeMaterial::blendMode, R"doc(Blend mode)doc")
        .def_readwrite("falloff_type", &whiteout::m3::VolumeMaterial::falloffType, R"doc(Density falloff type)doc")
        .def_readwrite("density", &whiteout::m3::VolumeMaterial::density, R"doc(Animated density)doc")
        .def_readwrite("color_map", &whiteout::m3::VolumeMaterial::colorMap, R"doc(Color map texture)doc")
        .def_readwrite("noise_map1", &whiteout::m3::VolumeMaterial::noiseMap1, R"doc(Noise map 1)doc")
        .def_readwrite("noise_map2", &whiteout::m3::VolumeMaterial::noiseMap2, R"doc(Noise map 2)doc")
        .def_readwrite("alpha_threshold", &whiteout::m3::VolumeMaterial::alphaThreshold, R"doc(Alpha test threshold)doc")
    ;

    py::class_<whiteout::m3::HairMaterial>(m, "HairMaterial", R"doc(HAI_ — Hair material (defunct, v0, 116 bytes)

Anisotropic hair rendering material with specular shift and AO. Always null in observed corpus data.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::HairMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("layer_base", &whiteout::m3::HairMaterial::layerBase, R"doc(Base color / diffuse texture)doc")
        .def_readwrite("layer_spec_shift", &whiteout::m3::HairMaterial::layerSpecShift, R"doc(Anisotropic specular shift map)doc")
        .def_readwrite("layer_spec_noise", &whiteout::m3::HairMaterial::layerSpecNoise, R"doc(Specular noise / break-up map)doc")
        .def_readwrite("layer_ao", &whiteout::m3::HairMaterial::layerAO, R"doc(Ambient occlusion map)doc")
        .def_readwrite("shift_primary", &whiteout::m3::HairMaterial::shiftPrimary, R"doc(Primary specular shift)doc")
        .def_readwrite("shift_secondary", &whiteout::m3::HairMaterial::shiftSecondary, R"doc(Secondary specular shift)doc")
        .def_readwrite("color_diffuse", &whiteout::m3::HairMaterial::colorDiffuse, R"doc(Animated diffuse tint)doc")
        .def_readwrite("color_spec", &whiteout::m3::HairMaterial::colorSpec, R"doc(Animated specular tint)doc")
        .def_readwrite("spec_exponent0", &whiteout::m3::HairMaterial::specExponent0, R"doc(Primary specular exponent)doc")
        .def_readwrite("spec_exponent1", &whiteout::m3::HairMaterial::specExponent1, R"doc(Secondary specular exponent)doc")
    ;

    py::class_<whiteout::m3::VolumeNoiseMaterial>(m, "VolumeNoiseMaterial", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::VolumeNoiseMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("falloff_type", &whiteout::m3::VolumeNoiseMaterial::falloffType, R"doc(Density falloff type)doc")
        .def_readwrite("draw_transparency", &whiteout::m3::VolumeNoiseMaterial::drawTransparency, R"doc(Camera position mode (inside/outside))doc")
        .def_readwrite("density", &whiteout::m3::VolumeNoiseMaterial::density, R"doc(Animated density)doc")
        .def_readwrite("near_plane", &whiteout::m3::VolumeNoiseMaterial::nearPlane, R"doc(Animated near-plane clip)doc")
        .def_readwrite("falloff", &whiteout::m3::VolumeNoiseMaterial::falloff, R"doc(Animated falloff distance)doc")
        .def_readwrite("color_map", &whiteout::m3::VolumeNoiseMaterial::colorMap, R"doc(Color map texture)doc")
        .def_readwrite("noise_map1", &whiteout::m3::VolumeNoiseMaterial::noiseMap1, R"doc(Noise map 1)doc")
        .def_readwrite("noise_map2", &whiteout::m3::VolumeNoiseMaterial::noiseMap2, R"doc(Noise map 2)doc")
        .def_readwrite("scroll_rate", &whiteout::m3::VolumeNoiseMaterial::scrollRate, R"doc(Animated noise scroll rate)doc")
        .def_readwrite("position", &whiteout::m3::VolumeNoiseMaterial::position, R"doc(Animated volume position)doc")
        .def_readwrite("scale", &whiteout::m3::VolumeNoiseMaterial::scale, R"doc(Animated volume scale)doc")
        .def_readwrite("rotation", &whiteout::m3::VolumeNoiseMaterial::rotation, R"doc(Animated volume rotation)doc")
        .def_readwrite("alpha_threshold", &whiteout::m3::VolumeNoiseMaterial::alphaThreshold, R"doc(Alpha test threshold)doc")
        .def_readwrite("flags", &whiteout::m3::VolumeNoiseMaterial::flags, R"doc(Volume noise material flags)doc")
    ;

    py::class_<whiteout::m3::CreepMaterial>(m, "CreepMaterial", R"doc(CREP — Creep material (v0–v1, 28 bytes)

Material for Zerg creep rendering with a mask map and creep-low parameter.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::CreepMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("mask_map", &whiteout::m3::CreepMaterial::maskMap, R"doc(Creep mask texture)doc")
        .def_readwrite("creep_low", &whiteout::m3::CreepMaterial::creepLow, R"doc(Creep low parameter)doc")
    ;

    py::class_<whiteout::m3::STBMaterial>(m, "STBMaterial", R"doc(STBM — Splat terrain bake material (v0, 48 bytes)

Material for baked terrain splat rendering with diffuse, normal, and specular texture layers.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::STBMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("diffuse_map", &whiteout::m3::STBMaterial::diffuseMap, R"doc(Diffuse / albedo map)doc")
        .def_readwrite("normal_map", &whiteout::m3::STBMaterial::normalMap, R"doc(Normal map)doc")
        .def_readwrite("specular_map", &whiteout::m3::STBMaterial::specularMap, R"doc(Specular map)doc")
    ;

    py::class_<whiteout::m3::ReflectionMaterial>(m, "ReflectionMaterial", R"doc(REF_ — Reflection material (v0–v3, 84–160 bytes)

Planar or cube-map reflection material with animated reflection/displacement strength, blur, and multiple texture layers.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::ReflectionMaterial::name, R"doc(Material name (Ref<CHAR>))doc")
        .def_readwrite("unknown", &whiteout::m3::ReflectionMaterial::unknown, R"doc(Unknown field)doc")
        .def_readwrite("reflection_strength", &whiteout::m3::ReflectionMaterial::reflectionStrength, R"doc(Animated reflection strength (v2+))doc")
        .def_readwrite("displacement_strength", &whiteout::m3::ReflectionMaterial::displacementStrength, R"doc(Animated displacement strength (v2+))doc")
        .def_readwrite("reflection_offset", &whiteout::m3::ReflectionMaterial::reflectionOffset, R"doc(Animated reflection offset (v2+))doc")
        .def_readwrite("blur_angle", &whiteout::m3::ReflectionMaterial::blurAngle, R"doc(Animated blur angle (v2+))doc")
        .def_readwrite("blur_distance_max", &whiteout::m3::ReflectionMaterial::blurDistanceMax, R"doc(Animated max blur distance (v2+))doc")
        .def_readwrite("reflection_map", &whiteout::m3::ReflectionMaterial::reflectionMap, R"doc(Reflection map texture)doc")
        .def_readwrite("displacement_map", &whiteout::m3::ReflectionMaterial::displacementMap, R"doc(Displacement map texture)doc")
        .def_readwrite("blur_map", &whiteout::m3::ReflectionMaterial::blurMap, R"doc(Blur map texture)doc")
        .def_readwrite("flags", &whiteout::m3::ReflectionMaterial::flags, R"doc(Reflection flags (v2+))doc")
        .def_readwrite("unknown2", &whiteout::m3::ReflectionMaterial::unknown2, R"doc(Unknown field)doc")
    ;

    py::class_<whiteout::m3::SubFlare>(m, "SubFlare", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("index", &whiteout::m3::SubFlare::index, R"doc(Flare element index)doc")
        .def_readwrite("position", &whiteout::m3::SubFlare::position, R"doc(Position along the flare axis (0–1))doc")
        .def_readwrite("size_xy", &whiteout::m3::SubFlare::sizeXY, R"doc(Base size (width, height))doc")
        .def_readwrite("scale_xy", &whiteout::m3::SubFlare::scaleXY, R"doc(Scale multiplier (width, height))doc")
        .def_readwrite("fade_in", &whiteout::m3::SubFlare::fadeIn, R"doc(Fade-in range (start, end))doc")
        .def_readwrite("fade_out", &whiteout::m3::SubFlare::fadeOut, R"doc(Fade-out range (start, end))doc")
        .def_readwrite("color_alpha", &whiteout::m3::SubFlare::colorAlpha, R"doc(Flare color and alpha)doc")
        .def_readwrite("face_center", &whiteout::m3::SubFlare::faceCenter, R"doc(Whether to face the flare center)doc")
        .def_readwrite("offset", &whiteout::m3::SubFlare::offset, R"doc(Offset from flare center)doc")
    ;

    py::class_<whiteout::m3::LensFlare>(m, "LensFlare", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::LensFlare::name, R"doc(Flare name (Ref<CHAR>))doc")
        .def_readwrite("flare_map", &whiteout::m3::LensFlare::flareMap, R"doc(Flare texture atlas)doc")
        .def_readwrite("mask_map", &whiteout::m3::LensFlare::maskMap, R"doc(Flare mask texture)doc")
        .def_readwrite("sub_flares", &whiteout::m3::LensFlare::subFlares, R"doc(Sub-flare elements (LFSB))doc")
        .def_readwrite("columns", &whiteout::m3::LensFlare::columns, R"doc(Flipbook grid columns)doc")
        .def_readwrite("rows", &whiteout::m3::LensFlare::rows, R"doc(Flipbook grid rows)doc")
        .def_readwrite("distance_fade", &whiteout::m3::LensFlare::distanceFade, R"doc(Distance fade start)doc")
        .def_readwrite("lib_name", &whiteout::m3::LensFlare::libName, R"doc(Library name (Ref<CHAR>))doc")
        .def_readwrite("intensity", &whiteout::m3::LensFlare::intensity, R"doc(Animated intensity)doc")
        .def_readwrite("color", &whiteout::m3::LensFlare::color, R"doc(Animated color)doc")
        .def_readwrite("hdr", &whiteout::m3::LensFlare::hdr, R"doc(Animated HDR multiplier)doc")
        .def_readwrite("size", &whiteout::m3::LensFlare::size, R"doc(Animated size)doc")
    ;

    py::class_<whiteout::m3::MaterialAddData>(m, "MaterialAddData", R"doc(MADD — Material additional data (v0–v3, 140–160 bytes)

Buffer-style material extension storing key–value pairs, hashes, and animation parameters. Added in MODL v30.)doc")
        .def(py::init<>())
        .def_readwrite("key_name", &whiteout::m3::MaterialAddData::keyName, R"doc(Key name (Ref<CHAR>))doc")
        .def_readwrite("key_hash", &whiteout::m3::MaterialAddData::keyHash, R"doc(Key hash values (U32_))doc")
        .def_readwrite("extra_hash", &whiteout::m3::MaterialAddData::extraHash, R"doc(Extra hash values (U32_, v2+))doc")
        .def_readwrite("value_path", &whiteout::m3::MaterialAddData::valuePath, R"doc(Value file path (Ref<CHAR>))doc")
        .def_readwrite("value_data", &whiteout::m3::MaterialAddData::valueData, R"doc(Value data strings)doc")
        .def_readwrite("frequency", &whiteout::m3::MaterialAddData::frequency, R"doc(Animation frequency)doc")
        .def_readwrite("intensity", &whiteout::m3::MaterialAddData::intensity, R"doc(Effect intensity)doc")
        .def_readwrite("hold_time", &whiteout::m3::MaterialAddData::holdTime, R"doc(Hold time duration)doc")
        .def_readwrite("random_hash", &whiteout::m3::MaterialAddData::randomHash, R"doc(Random seed hash)doc")
        .def_readwrite("animation_type", &whiteout::m3::MaterialAddData::animationType, R"doc(Animation type code)doc")
        .def_readwrite("padding0", &whiteout::m3::MaterialAddData::padding0, R"doc(Alignment padding)doc")
        .def_readwrite("loop_count", &whiteout::m3::MaterialAddData::loopCount, R"doc(Loop count (-1 = infinite))doc")
        .def_readwrite("flags", &whiteout::m3::MaterialAddData::flags, R"doc(Flags)doc")
        .def_readwrite("sub_type", &whiteout::m3::MaterialAddData::subType, R"doc(Sub-type identifier)doc")
        .def_readwrite("config_a", &whiteout::m3::MaterialAddData::configA, R"doc(Configuration parameter A)doc")
        .def_readwrite("config_b", &whiteout::m3::MaterialAddData::configB, R"doc(Configuration parameter B)doc")
        .def_readwrite("extra_id0", &whiteout::m3::MaterialAddData::extraId0, R"doc(Extra identifier 0 (v3+))doc")
        .def_readwrite("extra_id1", &whiteout::m3::MaterialAddData::extraId1, R"doc(Extra identifier 1 (v3+))doc")
        .def("get_reserved",
            [](const whiteout::m3::MaterialAddData& self) {
                return std::vector<whiteout::m3::Reference>(self.reserved.begin(), self.reserved.end());
            })
        .def("set_reserved",
            [](whiteout::m3::MaterialAddData& self, const std::vector<whiteout::m3::Reference>& v) {
                if (v.size() != self.reserved.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.reserved.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.reserved[i] = v[i];
            })
    ;

    py::class_<whiteout::m3::Bone>(m, "Bone", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("unknown", &whiteout::m3::Bone::unknown, R"doc(Unknown field)doc")
        .def_readwrite("name", &whiteout::m3::Bone::name, R"doc(Bone name (Ref<CHAR>))doc")
        .def_readwrite("flags", &whiteout::m3::Bone::flags, R"doc(Bone flags (inherit, billboard, IK, skin))doc")
        .def_readwrite("parent_index", &whiteout::m3::Bone::parentIndex, R"doc(Parent bone index (0xFFFF = root))doc")
        .def_readwrite("padding", &whiteout::m3::Bone::padding, R"doc(Alignment padding)doc")
        .def_readwrite("position", &whiteout::m3::Bone::position, R"doc(Animated translation (36 bytes))doc")
        .def_readwrite("rotation", &whiteout::m3::Bone::rotation, R"doc(Animated rotation (44 bytes))doc")
        .def_readwrite("scale", &whiteout::m3::Bone::scale, R"doc(Animated scale (36 bytes))doc")
        .def_readwrite("visibility", &whiteout::m3::Bone::visibility, R"doc(Animated visibility flag (20 bytes))doc")
    ;

    py::class_<whiteout::m3::Region>(m, "Region", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("index", &whiteout::m3::Region::index, R"doc(Region index)doc")
        .def_readwrite("unknown", &whiteout::m3::Region::unknown, R"doc(Unknown field)doc")
        .def_readwrite("first_vertex", &whiteout::m3::Region::firstVertex, R"doc(First vertex in the vertex buffer)doc")
        .def_readwrite("vertex_count", &whiteout::m3::Region::vertexCount, R"doc(Number of vertices)doc")
        .def_readwrite("first_index", &whiteout::m3::Region::firstIndex, R"doc(First index in the index buffer)doc")
        .def_readwrite("index_count", &whiteout::m3::Region::indexCount, R"doc(Number of indices (triangles × 3))doc")
        .def_readwrite("unknown2", &whiteout::m3::Region::unknown2, R"doc(Unknown field)doc")
        .def_readwrite("first_bone_lookup", &whiteout::m3::Region::firstBoneLookup, R"doc(First entry in bone lookup table)doc")
        .def_readwrite("bone_lookup_count", &whiteout::m3::Region::boneLookupCount, R"doc(Number of bone lookup entries)doc")
        .def_readwrite("padding", &whiteout::m3::Region::padding, R"doc(Alignment padding)doc")
        .def_readwrite("bone_weight_pairs", &whiteout::m3::Region::boneWeightPairs, R"doc(Number of bone weight pairs per vertex)doc")
        .def_readwrite("bone_index_pairs", &whiteout::m3::Region::boneIndexPairs, R"doc(Number of bone index pairs per vertex)doc")
        .def_readwrite("root_bone", &whiteout::m3::Region::rootBone, R"doc(Root bone for this region)doc")
        .def_readwrite("flags", &whiteout::m3::Region::flags, R"doc(Region flags (hidden, cloth, etc.))doc")
        .def_readwrite("uv_scale", &whiteout::m3::Region::uvScale, R"doc(UV coordinate scale factor)doc")
        .def_readwrite("uv_offset", &whiteout::m3::Region::uvOffset, R"doc(UV coordinate offset)doc")
    ;

    py::class_<whiteout::m3::Batch>(m, "Batch", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("unknown", &whiteout::m3::Batch::unknown, R"doc(Unknown field)doc")
        .def_readwrite("region_index", &whiteout::m3::Batch::regionIndex, R"doc(Index into REGN array)doc")
        .def_readwrite("unknown2", &whiteout::m3::Batch::unknown2, R"doc(Unknown field)doc")
        .def_readwrite("material_index", &whiteout::m3::Batch::materialIndex, R"doc(Index into MATM material map array)doc")
        .def_readwrite("bone_count", &whiteout::m3::Batch::boneCount, R"doc(Number of bones affecting this batch)doc")
    ;

    py::class_<whiteout::m3::MeshSection>(m, "MeshSection", R"doc(MSEC — Mesh section bounds (v0–v1, 80 bytes)

Per-node animated bounding extent used for culling and LOD.)doc")
        .def(py::init<>())
        .def_readwrite("node_index", &whiteout::m3::MeshSection::nodeIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("bounds", &whiteout::m3::MeshSection::bounds, R"doc(Animated bounding volume (76 bytes))doc")
    ;

    py::class_<whiteout::m3::MeshDivision>(m, "MeshDivision", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("faces", &whiteout::m3::MeshDivision::faces, R"doc(Triangle indices (U16_))doc")
        .def_readwrite("regions", &whiteout::m3::MeshDivision::regions, R"doc(Regions / submeshes (REGN))doc")
        .def_readwrite("batches", &whiteout::m3::MeshDivision::batches, R"doc(Draw call batches (BAT_))doc")
        .def_readwrite("msec", &whiteout::m3::MeshDivision::msec, R"doc(Per-node mesh section bounds (MSEC))doc")
        .def_readwrite("instances", &whiteout::m3::MeshDivision::instances, R"doc(Instance count)doc")
    ;

    py::class_<whiteout::m3::InitialReference>(m, "InitialReference", R"doc(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.)doc")
        .def(py::init<>())
    ;

    py::class_<whiteout::m3::AttachmentPoint>(m, "AttachmentPoint", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("unknown", &whiteout::m3::AttachmentPoint::unknown, R"doc(Unknown field)doc")
        .def_readwrite("name", &whiteout::m3::AttachmentPoint::name, R"doc(Attachment point name (Ref<CHAR>))doc")
        .def_readwrite("bone_index", &whiteout::m3::AttachmentPoint::boneIndex, R"doc(Index into BONE array)doc")
    ;

    py::class_<whiteout::m3::HitTestShape>(m, "HitTestShape", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("shape_type", &whiteout::m3::HitTestShape::shapeType, R"doc(Shape type (box/sphere/capsule/cylinder/mesh))doc")
        .def_readwrite("bone_index", &whiteout::m3::HitTestShape::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("padding", &whiteout::m3::HitTestShape::padding, R"doc(Alignment padding)doc")
        .def_readwrite("vertex_positions", &whiteout::m3::HitTestShape::vertexPositions, R"doc(Mesh vertex positions (VEC3, mesh type only))doc")
        .def_readwrite("face_indices", &whiteout::m3::HitTestShape::faceIndices, R"doc(Mesh triangle indices (U16_, mesh type only))doc")
        .def_readwrite("size_x", &whiteout::m3::HitTestShape::sizeX, R"doc(X dimension (radius for sphere/capsule))doc")
        .def_readwrite("size_y", &whiteout::m3::HitTestShape::sizeY, R"doc(Y dimension (height for capsule/cylinder))doc")
        .def_readwrite("size_z", &whiteout::m3::HitTestShape::sizeZ, R"doc(Z dimension)doc")
    ;

    py::class_<whiteout::m3::AttachmentVolume>(m, "AttachmentVolume", R"doc(ATVL — Attachment volume (v0, 116 bytes)

Like HitTestShape but with two bone indices for attachment-point volumes.)doc")
        .def(py::init<>())
        .def_readwrite("bone1", &whiteout::m3::AttachmentVolume::bone1, R"doc(First bone index)doc")
        .def_readwrite("bone2", &whiteout::m3::AttachmentVolume::bone2, R"doc(Second bone index)doc")
        .def_readwrite("shape_type", &whiteout::m3::AttachmentVolume::shapeType, R"doc(Shape type)doc")
        .def_readwrite("bone_index", &whiteout::m3::AttachmentVolume::boneIndex, R"doc(Primary bone index)doc")
        .def_readwrite("padding", &whiteout::m3::AttachmentVolume::padding, R"doc(Alignment padding)doc")
        .def_readwrite("vertex_positions", &whiteout::m3::AttachmentVolume::vertexPositions, R"doc(Mesh vertex positions (VEC3))doc")
        .def_readwrite("face_indices", &whiteout::m3::AttachmentVolume::faceIndices, R"doc(Mesh triangle indices (U16_))doc")
        .def_readwrite("size_x", &whiteout::m3::AttachmentVolume::sizeX, R"doc(X dimension)doc")
        .def_readwrite("size_y", &whiteout::m3::AttachmentVolume::sizeY, R"doc(Y dimension)doc")
        .def_readwrite("size_z", &whiteout::m3::AttachmentVolume::sizeZ, R"doc(Z dimension)doc")
    ;

    py::class_<whiteout::m3::TriggerData>(m, "TriggerData", R"doc(TRGD — Trigger data (v0, 24 bytes)

Named trigger with associated data indices for gameplay events.)doc")
        .def(py::init<>())
        .def_readwrite("data_indices", &whiteout::m3::TriggerData::dataIndices, R"doc(Data index array (U32_))doc")
        .def_readwrite("name", &whiteout::m3::TriggerData::name, R"doc(Trigger name (Ref<CHAR>))doc")
    ;

    py::class_<whiteout::m3::TurretBehavior>(m, "TurretBehavior", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("unknown1", &whiteout::m3::TurretBehavior::unknown1, R"doc(Unknown vector 1)doc")
        .def_readwrite("unknown2", &whiteout::m3::TurretBehavior::unknown2, R"doc(Unknown vector 2)doc")
        .def_readwrite("bone_index", &whiteout::m3::TurretBehavior::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("use_as_main_turret", &whiteout::m3::TurretBehavior::useAsMainTurret, R"doc(Non-zero if this is the main turret)doc")
        .def_readwrite("turret_group_id", &whiteout::m3::TurretBehavior::turretGroupId, R"doc(Turret group identifier)doc")
        .def_readwrite("yaw_limited", &whiteout::m3::TurretBehavior::yawLimited, R"doc(Enable yaw limits)doc")
        .def_readwrite("yaw_min", &whiteout::m3::TurretBehavior::yawMin, R"doc(Minimum yaw angle (radians))doc")
        .def_readwrite("yaw_max", &whiteout::m3::TurretBehavior::yawMax, R"doc(Maximum yaw angle (radians))doc")
        .def_readwrite("yaw_weight", &whiteout::m3::TurretBehavior::yawWeight, R"doc(Yaw rotation weight)doc")
        .def_readwrite("pitch_limited", &whiteout::m3::TurretBehavior::pitchLimited, R"doc(Enable pitch limits)doc")
        .def_readwrite("pitch_min", &whiteout::m3::TurretBehavior::pitchMin, R"doc(Minimum pitch angle (radians))doc")
        .def_readwrite("pitch_max", &whiteout::m3::TurretBehavior::pitchMax, R"doc(Maximum pitch angle (radians))doc")
        .def_readwrite("pitch_weight", &whiteout::m3::TurretBehavior::pitchWeight, R"doc(Pitch rotation weight)doc")
        .def_readwrite("unknown3", &whiteout::m3::TurretBehavior::unknown3, R"doc(Unknown field)doc")
        .def_readwrite("unknown4", &whiteout::m3::TurretBehavior::unknown4, R"doc(Unknown field)doc")
        .def_readwrite("main_bone_offset", &whiteout::m3::TurretBehavior::mainBoneOffset, R"doc(Offset from main bone)doc")
    ;

    py::class_<whiteout::m3::BillboardBehavior>(m, "BillboardBehavior", R"doc(BBSC — Billboard behavior (v0, 48 bytes)

Makes a bone always face the camera or a specified direction.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::BillboardBehavior::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("bone_index", &whiteout::m3::BillboardBehavior::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("billboard_type", &whiteout::m3::BillboardBehavior::billboardType, R"doc(Billboard mode type)doc")
        .def_readwrite("camera_look_at", &whiteout::m3::BillboardBehavior::cameraLookAt, R"doc(Camera look-at flag (default: enabled))doc")
        .def_readwrite("up", &whiteout::m3::BillboardBehavior::up, R"doc(Up direction quaternion)doc")
        .def_readwrite("forward", &whiteout::m3::BillboardBehavior::forward, R"doc(Forward direction quaternion)doc")
    ;

    py::class_<whiteout::m3::IKJoint>(m, "IKJoint", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::IKJoint::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("bone_index1", &whiteout::m3::IKJoint::boneIndex1, R"doc(First bone index)doc")
        .def_readwrite("bone_index2", &whiteout::m3::IKJoint::boneIndex2, R"doc(Second bone index)doc")
        .def_readwrite("raycast_up", &whiteout::m3::IKJoint::raycastUp, R"doc(Raycast upward distance)doc")
        .def_readwrite("raycast_down", &whiteout::m3::IKJoint::raycastDown, R"doc(Raycast downward distance)doc")
        .def_readwrite("max_speed", &whiteout::m3::IKJoint::maxSpeed, R"doc(Maximum IK solving speed)doc")
        .def_readwrite("goal_threshold", &whiteout::m3::IKJoint::goalThreshold, R"doc(Goal distance threshold)doc")
    ;

    py::class_<whiteout::m3::IKTwoJoint>(m, "IKTwoJoint", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::IKTwoJoint::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("bone_base", &whiteout::m3::IKTwoJoint::boneBase, R"doc(Base bone (e.g. upper arm/thigh))doc")
        .def_readwrite("bone_target", &whiteout::m3::IKTwoJoint::boneTarget, R"doc(Target bone (e.g. forearm/shin))doc")
        .def_readwrite("bone_end", &whiteout::m3::IKTwoJoint::boneEnd, R"doc(End effector bone (e.g. hand/foot))doc")
        .def_readwrite("padding", &whiteout::m3::IKTwoJoint::padding, R"doc(Alignment padding)doc")
        .def_readwrite("hinge_axis", &whiteout::m3::IKTwoJoint::hingeAxis, R"doc(Hinge rotation axis)doc")
        .def_readwrite("max_angle_inner", &whiteout::m3::IKTwoJoint::maxAngleInner, R"doc(Maximum inner angle)doc")
        .def_readwrite("max_angle_outer", &whiteout::m3::IKTwoJoint::maxAngleOuter, R"doc(Maximum outer angle)doc")
        .def_readwrite("search_up", &whiteout::m3::IKTwoJoint::searchUp, R"doc(Search range upward)doc")
        .def_readwrite("search_down", &whiteout::m3::IKTwoJoint::searchDown, R"doc(Search range downward)doc")
    ;

    py::class_<whiteout::m3::IKCCD>(m, "IKCCD", R"doc(IKCC — CCD IK solver (v0, 24 bytes)

Cyclic Coordinate Descent IK solver with base/target bones and vertical search range.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::IKCCD::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("bone_base", &whiteout::m3::IKCCD::boneBase, R"doc(Base bone index)doc")
        .def_readwrite("bone_target", &whiteout::m3::IKCCD::boneTarget, R"doc(Target bone index)doc")
        .def_readwrite("search_up", &whiteout::m3::IKCCD::searchUp, R"doc(Search range upward)doc")
        .def_readwrite("search_down", &whiteout::m3::IKCCD::searchDown, R"doc(Search range downward)doc")
    ;

    py::class_<whiteout::m3::OneBoneSolver>(m, "OneBoneSolver", R"doc(PAOB — One-bone IK solver (v0, 24 bytes)

Simple single-bone orientation solver with angle limit and fallback bone.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::OneBoneSolver::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("bone", &whiteout::m3::OneBoneSolver::bone, R"doc(Primary bone index)doc")
        .def_readwrite("bone_fallback", &whiteout::m3::OneBoneSolver::boneFallback, R"doc(Fallback bone index)doc")
        .def_readwrite("max_angle", &whiteout::m3::OneBoneSolver::maxAngle, R"doc(Maximum rotation angle)doc")
    ;

    py::class_<whiteout::m3::ShadowBox>(m, "ShadowBox", R"doc(SHBX — Shadow box (v0, 64 bytes)

Axis-aligned shadow volume defined by a 4×4 transform matrix.)doc")
        .def(py::init<>())
    ;

    py::class_<whiteout::m3::ViewVolume>(m, "ViewVolume", R"doc(VVOL — View volume (v0, 40 bytes)

Animated visibility volume bound to a bone, used for culling decisions.)doc")
        .def(py::init<>())
        .def_readwrite("node_index", &whiteout::m3::ViewVolume::nodeIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("size", &whiteout::m3::ViewVolume::size, R"doc(Animated half-extents (36 bytes))doc")
    ;

    py::class_<whiteout::m3::TrailingModel>(m, "TrailingModel", R"doc(TMD_ — Trailing model (v0–v1, defunct)

Legacy trailing model data. Observed in older files but no longer actively used by the engine.)doc")
        .def(py::init<>())
        .def_readwrite("vectors", &whiteout::m3::TrailingModel::vectors, R"doc(Control vectors (VEC3))doc")
        .def_readwrite("param0", &whiteout::m3::TrailingModel::param0, R"doc(Parameter 0 (observed: 5.0))doc")
        .def_readwrite("param1", &whiteout::m3::TrailingModel::param1, R"doc(Parameter 1 (observed: 1.0))doc")
        .def_readwrite("anim_float0", &whiteout::m3::TrailingModel::animFloat0, R"doc(Animated float 0 (init 0.5))doc")
        .def_readwrite("anim_float1", &whiteout::m3::TrailingModel::animFloat1, R"doc(Animated float 1 (init 1.0))doc")
        .def_readwrite("flag", &whiteout::m3::TrailingModel::flag, R"doc(Flag (observed: 1))doc")
        .def_readwrite("reserved0", &whiteout::m3::TrailingModel::reserved0, R"doc(Reserved)doc")
        .def_readwrite("reserved1", &whiteout::m3::TrailingModel::reserved1, R"doc(Reserved)doc")
    ;

    py::class_<whiteout::m3::Force>(m, "Force", R"doc(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).)doc")
        .def(py::init<>())
        .def_readwrite("force_type", &whiteout::m3::Force::forceType, R"doc(Force influence type (radial/wind/explosion))doc")
        .def_readwrite("force_shape", &whiteout::m3::Force::forceShape, R"doc(Influence volume shape)doc")
        .def_readwrite("unknown", &whiteout::m3::Force::unknown, R"doc(Unknown field)doc")
        .def_readwrite("bone_index", &whiteout::m3::Force::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("flags", &whiteout::m3::Force::flags, R"doc(Force flags (falloff, height gradient, unbounded))doc")
        .def_readwrite("local_channels", &whiteout::m3::Force::localChannels, R"doc(Local channel bitmask)doc")
        .def_readwrite("strength", &whiteout::m3::Force::strength, R"doc(Animated force strength)doc")
        .def_readwrite("width", &whiteout::m3::Force::width, R"doc(Animated influence width)doc")
        .def_readwrite("height", &whiteout::m3::Force::height, R"doc(Animated influence height)doc")
        .def_readwrite("length", &whiteout::m3::Force::length, R"doc(Animated influence length)doc")
    ;

    py::class_<whiteout::m3::Warp>(m, "Warp", R"doc(WRP_ — Warp field (v0–v1, 132 bytes)

Warps particle/ribbon trajectories with animated radius, height, and angular/axial/radial strength components.)doc")
        .def(py::init<>())
        .def_readwrite("warp_type", &whiteout::m3::Warp::warpType, R"doc(Warp type)doc")
        .def_readwrite("bone_index", &whiteout::m3::Warp::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("unknown", &whiteout::m3::Warp::unknown, R"doc(Unknown field)doc")
        .def_readwrite("radius", &whiteout::m3::Warp::radius, R"doc(Animated warp radius)doc")
        .def_readwrite("height", &whiteout::m3::Warp::height, R"doc(Animated warp height)doc")
        .def_readwrite("strength", &whiteout::m3::Warp::strength, R"doc(Animated warp strength)doc")
        .def_readwrite("angular", &whiteout::m3::Warp::angular, R"doc(Animated angular component)doc")
        .def_readwrite("axial", &whiteout::m3::Warp::axial, R"doc(Animated axial component)doc")
        .def_readwrite("radial", &whiteout::m3::Warp::radial, R"doc(Animated radial component)doc")
    ;

    py::class_<whiteout::m3::ConvexHullHalfEdge>(m, "ConvexHullHalfEdge", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("type", &whiteout::m3::ConvexHullHalfEdge::type, R"doc(0x01 = forward, 0xFF = reverse (twin))doc")
        .def_readwrite("face_index", &whiteout::m3::ConvexHullHalfEdge::faceIndex, R"doc(Face this half-edge borders)doc")
        .def_readwrite("vertex_index", &whiteout::m3::ConvexHullHalfEdge::vertexIndex, R"doc(Target vertex of this half-edge)doc")
        .def_readwrite("next_around_vertex", &whiteout::m3::ConvexHullHalfEdge::nextAroundVertex, R"doc(Next half-edge around the same vertex)doc")
    ;

    py::class_<whiteout::m3::PhysicsMeshBvhNode>(m, "PhysicsMeshBvhNode", R"doc(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).)doc")
        .def(py::init<>())
    ;

    py::class_<whiteout::m3::PhysicsMeshTriangle>(m, "PhysicsMeshTriangle", R"doc(DMMT — Physics mesh triangle (v0, 28 bytes))doc")
        .def(py::init<>())
        .def_readwrite("vertex_index0", &whiteout::m3::PhysicsMeshTriangle::vertexIndex0, R"doc(First vertex index)doc")
        .def_readwrite("vertex_index1", &whiteout::m3::PhysicsMeshTriangle::vertexIndex1, R"doc(Second vertex index)doc")
        .def_readwrite("vertex_index2", &whiteout::m3::PhysicsMeshTriangle::vertexIndex2, R"doc(Third vertex index)doc")
        .def_readwrite("edge_index0", &whiteout::m3::PhysicsMeshTriangle::edgeIndex0, R"doc(First edge index)doc")
        .def_readwrite("edge_index1", &whiteout::m3::PhysicsMeshTriangle::edgeIndex1, R"doc(Second edge index)doc")
        .def_readwrite("edge_index2", &whiteout::m3::PhysicsMeshTriangle::edgeIndex2, R"doc(Third edge index)doc")
        .def_readwrite("reserved", &whiteout::m3::PhysicsMeshTriangle::reserved, R"doc(Reserved)doc")
        .def_readwrite("flags", &whiteout::m3::PhysicsMeshTriangle::flags, R"doc(Triangle flags)doc")
    ;

    py::class_<whiteout::m3::PhysicsMeshEdge>(m, "PhysicsMeshEdge", R"doc(DMME — Physics mesh edge (v0, 20 bytes))doc")
        .def(py::init<>())
        .def_readwrite("edge_type", &whiteout::m3::PhysicsMeshEdge::edgeType, R"doc(Edge type)doc")
        .def_readwrite("vertex_a", &whiteout::m3::PhysicsMeshEdge::vertexA, R"doc(First vertex index)doc")
        .def_readwrite("vertex_b", &whiteout::m3::PhysicsMeshEdge::vertexB, R"doc(Second vertex index)doc")
        .def_readwrite("face_a", &whiteout::m3::PhysicsMeshEdge::faceA, R"doc(First adjacent face)doc")
        .def_readwrite("face_b", &whiteout::m3::PhysicsMeshEdge::faceB, R"doc(Second adjacent face)doc")
    ;

    py::class_<whiteout::m3::PhysicsShape>(m, "PhysicsShape", R"doc(PHSH — Physics shape (v0–v3, 132–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).)doc")
        .def(py::init<>())
        .def_readwrite("collision_margin", &whiteout::m3::PhysicsShape::collisionMargin, R"doc(Havok convex radius (v1 only, ≈ 0.019685))doc")
        .def_readwrite("shape_type", &whiteout::m3::PhysicsShape::shapeType, R"doc(Shape type (box/sphere/capsule/cylinder/hull/mesh))doc")
        .def_readwrite("old_sizes", &whiteout::m3::PhysicsShape::oldSizes, R"doc(Legacy sizes (v1 only, zero for shapeType 4–5))doc")
        .def_readwrite("shape_dimensions", &whiteout::m3::PhysicsShape::shapeDimensions, R"doc(Shape dimensions (v2+, zero for complex shapes))doc")
        .def_readwrite("hull_face_normals", &whiteout::m3::PhysicsShape::hullFaceNormals, R"doc(Per-face unit normals (VEC3))doc")
        .def_readwrite("hull_vertex_positions", &whiteout::m3::PhysicsShape::hullVertexPositions, R"doc(Vertex positions, w=0 (VEC4))doc")
        .def_readwrite("hull_half_edges", &whiteout::m3::PhysicsShape::hullHalfEdges, R"doc(Half-edge table (DMSE))doc")
        .def_readwrite("hull_vertex_face_indices", &whiteout::m3::PhysicsShape::hullVertexFaceIndices, R"doc(One face index per vertex (U8__))doc")
        .def_readwrite("hull_center", &whiteout::m3::PhysicsShape::hullCenter, R"doc(Hull centroid)doc")
        .def_readwrite("hull_face_normal_count", &whiteout::m3::PhysicsShape::hullFaceNormalCount, R"doc(Number of face normals)doc")
        .def_readwrite("hull_vertex_count", &whiteout::m3::PhysicsShape::hullVertexCount, R"doc(Number of vertices)doc")
        .def_readwrite("hull_half_edge_count", &whiteout::m3::PhysicsShape::hullHalfEdgeCount, R"doc(Number of half-edges)doc")
        .def_readwrite("hull_unknown0", &whiteout::m3::PhysicsShape::hullUnknown0, R"doc(Unknown hull parameter 0)doc")
        .def_readwrite("hull_unknown1", &whiteout::m3::PhysicsShape::hullUnknown1, R"doc(Unknown hull parameter 1)doc")
        .def_readwrite("mesh_bvh_nodes", &whiteout::m3::PhysicsShape::meshBvhNodes, R"doc(BVH tree nodes (DMMN))doc")
        .def_readwrite("mesh_vertex_positions", &whiteout::m3::PhysicsShape::meshVertexPositions, R"doc(Vertex positions, w=0 (VEC4))doc")
        .def_readwrite("mesh_bounds_center", &whiteout::m3::PhysicsShape::meshBoundsCenter, R"doc(AABB center in model space (quantization grid origin))doc")
        .def_readwrite("mesh_bounds_extent", &whiteout::m3::PhysicsShape::meshBoundsExtent, R"doc(AABB half-extents (quantization range: tolerance = extent / 32767))doc")
        .def_readwrite("mesh_tolerance", &whiteout::m3::PhysicsShape::meshTolerance, R"doc(Per-axis quantization step (= extent / 32767))doc")
        .def_readwrite("mesh_normal_count", &whiteout::m3::PhysicsShape::meshNormalCount, R"doc(Number of mesh normals)doc")
        .def_readwrite("mesh_vertex_count", &whiteout::m3::PhysicsShape::meshVertexCount, R"doc(Number of mesh vertices)doc")
        .def_readwrite("mesh_face_index16_count", &whiteout::m3::PhysicsShape::meshFaceIndex16Count, R"doc(MT16 face count (0 when MT32))doc")
        .def_readwrite("mesh_face_index32_count", &whiteout::m3::PhysicsShape::meshFaceIndex32Count, R"doc(MT32 face count (0 when MT16))doc")
        .def_readwrite("mesh_unknown1", &whiteout::m3::PhysicsShape::meshUnknown1, R"doc(Unknown mesh parameter)doc")
        .def_readwrite("mesh_reserved", &whiteout::m3::PhysicsShape::meshReserved, R"doc(Reserved (always 0))doc")
        .def_readwrite("mesh_tree_depth", &whiteout::m3::PhysicsShape::meshTreeDepth, R"doc(BVH tree height (root-to-leaf path length, 1–12))doc")
        .def_readwrite("mesh_collision_margin", &whiteout::m3::PhysicsShape::meshCollisionMargin, R"doc(Collision margin (MT16: small float; MT32: 0.0))doc")
    ;

    py::class_<whiteout::m3::RigidBody>(m, "RigidBody", R"doc(PHRB — Rigid body (v2–v4, 56–104 bytes)

Havok rigid body with density, friction, restitution, damping, gravity scale, and collision shape references.)doc")
        .def(py::init<>())
        .def_readwrite("simulation_type", &whiteout::m3::RigidBody::simulationType, R"doc(Simulation mode (v3+))doc")
        .def_readwrite("parent_bone_index", &whiteout::m3::RigidBody::parentBoneIndex, R"doc(Parent bone index)doc")
        .def_readwrite("physics_type", &whiteout::m3::RigidBody::physicsType, R"doc(Engine-specific body type (v3+))doc")
        .def_readwrite("density", &whiteout::m3::RigidBody::density, R"doc(Body density)doc")
        .def_readwrite("friction", &whiteout::m3::RigidBody::friction, R"doc(Surface friction)doc")
        .def_readwrite("restitution", &whiteout::m3::RigidBody::restitution, R"doc(Elasticity / bounciness)doc")
        .def_readwrite("linear_damping", &whiteout::m3::RigidBody::linearDamping, R"doc(Linear velocity damping)doc")
        .def_readwrite("angular_damping", &whiteout::m3::RigidBody::angularDamping, R"doc(Angular velocity damping)doc")
        .def_readwrite("gravity_scale", &whiteout::m3::RigidBody::gravityScale, R"doc(Gravity influence scale)doc")
        .def_readwrite("dynamic_state", &whiteout::m3::RigidBody::dynamicState, R"doc(Animated dynamic state (v4+))doc")
        .def_readwrite("dynamic_blend_out", &whiteout::m3::RigidBody::dynamicBlendOut, R"doc(Dynamic blend-out duration (v4+))doc")
        .def_readwrite("rigid_body_shape", &whiteout::m3::RigidBody::rigidBodyShape, R"doc(Collision shapes (PHSH))doc")
        .def_readwrite("flags", &whiteout::m3::RigidBody::flags, R"doc(Rigid body flags)doc")
        .def_readwrite("local_forces", &whiteout::m3::RigidBody::localForces, R"doc(Local force channel bitmask)doc")
        .def_readwrite("world_forces", &whiteout::m3::RigidBody::worldForces, R"doc(World force channel bitmask)doc")
        .def_readwrite("priority", &whiteout::m3::RigidBody::priority, R"doc(Simulation priority)doc")
    ;

    py::class_<whiteout::m3::PhysicsJoint>(m, "PhysicsJoint", R"doc(PHYJ — Physics joint (v0, 180 bytes)

Connects two rigid bodies with limit, friction, and break-threshold parameters.)doc")
        .def(py::init<>())
        .def_readwrite("joint_type", &whiteout::m3::PhysicsJoint::jointType, R"doc(Joint type)doc")
        .def_readwrite("bone_index1", &whiteout::m3::PhysicsJoint::boneIndex1, R"doc(First bone index)doc")
        .def_readwrite("bone_index2", &whiteout::m3::PhysicsJoint::boneIndex2, R"doc(Second bone index)doc")
        .def_readwrite("enable_limits", &whiteout::m3::PhysicsJoint::enableLimits, R"doc(Enable angular limits)doc")
        .def_readwrite("limit_min", &whiteout::m3::PhysicsJoint::limitMin, R"doc(Minimum limit angle)doc")
        .def_readwrite("limit_max", &whiteout::m3::PhysicsJoint::limitMax, R"doc(Maximum limit angle)doc")
        .def_readwrite("cone_angle", &whiteout::m3::PhysicsJoint::coneAngle, R"doc(Cone constraint angle)doc")
        .def_readwrite("enable_friction", &whiteout::m3::PhysicsJoint::enableFriction, R"doc(Enable joint friction)doc")
        .def_readwrite("friction", &whiteout::m3::PhysicsJoint::friction, R"doc(Friction coefficient)doc")
        .def_readwrite("damping_ratio", &whiteout::m3::PhysicsJoint::dampingRatio, R"doc(Damping ratio)doc")
        .def_readwrite("angular_frequency", &whiteout::m3::PhysicsJoint::angularFrequency, R"doc(Angular frequency)doc")
        .def_readwrite("break_threshold", &whiteout::m3::PhysicsJoint::breakThreshold, R"doc(Force threshold to break joint)doc")
        .def_readwrite("enable_shape", &whiteout::m3::PhysicsJoint::enableShape, R"doc(Enable shape constraint)doc")
    ;

    py::class_<whiteout::m3::PhysicsConstraint>(m, "PhysicsConstraint", R"doc(PHCT — Physics constraint (v0, 24 bytes)

Constrains two rigid bodies with break-force threshold.)doc")
        .def(py::init<>())
        .def_readwrite("dependents", &whiteout::m3::PhysicsConstraint::dependents, R"doc(Dependent bone indices (U16_))doc")
        .def_readwrite("rigid_body1", &whiteout::m3::PhysicsConstraint::rigidBody1, R"doc(First rigid body index)doc")
        .def_readwrite("rigid_body2", &whiteout::m3::PhysicsConstraint::rigidBody2, R"doc(Second rigid body index)doc")
        .def_readwrite("break_force", &whiteout::m3::PhysicsConstraint::breakForce, R"doc(Force required to break constraint)doc")
    ;

    py::class_<whiteout::m3::ClothCollider>(m, "ClothCollider", R"doc(PHCC — Cloth collider (v0, 76 bytes)

Capsule-shaped collider used by cloth simulation.)doc")
        .def(py::init<>())
        .def_readwrite("radius", &whiteout::m3::ClothCollider::radius, R"doc(Capsule radius)doc")
        .def_readwrite("height", &whiteout::m3::ClothCollider::height, R"doc(Capsule height)doc")
        .def_readwrite("padding", &whiteout::m3::ClothCollider::padding, R"doc(Alignment padding)doc")
    ;

    py::class_<whiteout::m3::ClothProxy>(m, "ClothProxy", R"doc(PHAC — Cloth proxy (v0, 32 bytes)

Maps cloth vertices to proxy geometry for collision.)doc")
        .def(py::init<>())
        .def_readwrite("proxy_index", &whiteout::m3::ClothProxy::proxyIndex, R"doc(Proxy mesh index)doc")
        .def_readwrite("cloth_index", &whiteout::m3::ClothProxy::clothIndex, R"doc(Cloth mesh index)doc")
        .def_readwrite("proxy_vertices", &whiteout::m3::ClothProxy::proxyVertices, R"doc(Proxy vertex data (U64_))doc")
        .def_readwrite("proxy_weights", &whiteout::m3::ClothProxy::proxyWeights, R"doc(Proxy blend weights (U32_))doc")
    ;

    py::class_<whiteout::m3::ClothPhysics>(m, "ClothPhysics", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("cloth_mesh_count", &whiteout::m3::ClothPhysics::clothMeshCount, R"doc(Number of cloth mesh sections)doc")
        .def_readwrite("skin_bone_count", &whiteout::m3::ClothPhysics::skinBoneCount, R"doc(Number of skin bones)doc")
        .def_readwrite("skin_bones", &whiteout::m3::ClothPhysics::skinBones, R"doc(Skin bone indices (U16_))doc")
        .def_readwrite("sim_enabled", &whiteout::m3::ClothPhysics::simEnabled, R"doc(Per-vertex simulation enable flags (U8__))doc")
        .def_readwrite("vertex_bones", &whiteout::m3::ClothPhysics::vertexBones, R"doc(Per-vertex bone indices (U32_))doc")
        .def_readwrite("vertex_weights", &whiteout::m3::ClothPhysics::vertexWeights, R"doc(Per-vertex bone weights (U32_))doc")
        .def_readwrite("colliders", &whiteout::m3::ClothPhysics::colliders, R"doc(Cloth colliders (PHCC))doc")
        .def_readwrite("proxies", &whiteout::m3::ClothPhysics::proxies, R"doc(Cloth proxies (PHAC))doc")
        .def_readwrite("density", &whiteout::m3::ClothPhysics::density, R"doc(Cloth density)doc")
        .def_readwrite("tracking", &whiteout::m3::ClothPhysics::tracking, R"doc(Tracking factor)doc")
        .def_readwrite("stretch_stiffness", &whiteout::m3::ClothPhysics::stretchStiffness, R"doc(Stretch stiffness)doc")
        .def_readwrite("horizontal_stiffness", &whiteout::m3::ClothPhysics::horizontalStiffness, R"doc(Horizontal stiffness)doc")
        .def_readwrite("bending_stiffness", &whiteout::m3::ClothPhysics::bendingStiffness, R"doc(Bending stiffness)doc")
        .def_readwrite("damping", &whiteout::m3::ClothPhysics::damping, R"doc(Damping coefficient)doc")
        .def_readwrite("friction", &whiteout::m3::ClothPhysics::friction, R"doc(Friction coefficient)doc")
        .def_readwrite("gravity", &whiteout::m3::ClothPhysics::gravity, R"doc(Gravity influence)doc")
        .def_readwrite("explosion_scale", &whiteout::m3::ClothPhysics::explosionScale, R"doc(Explosion force scale)doc")
        .def_readwrite("wind_scale", &whiteout::m3::ClothPhysics::windScale, R"doc(Wind force scale)doc")
        .def_readwrite("shear_stiffness", &whiteout::m3::ClothPhysics::shearStiffness, R"doc(Shear stiffness)doc")
        .def_readwrite("drag_factor", &whiteout::m3::ClothPhysics::dragFactor, R"doc(Drag factor)doc")
        .def_readwrite("lift_factor", &whiteout::m3::ClothPhysics::liftFactor, R"doc(Lift factor (v4+))doc")
        .def_readwrite("sphere_stiffness", &whiteout::m3::ClothPhysics::sphereStiffness, R"doc(Sphere collider stiffness (v4+))doc")
        .def_readwrite("flatten", &whiteout::m3::ClothPhysics::flatten, R"doc(Flatten mode (v4+))doc")
        .def_readwrite("active", &whiteout::m3::ClothPhysics::active, R"doc(Animated active state)doc")
        .def_readwrite("use_skin_collision", &whiteout::m3::ClothPhysics::useSkinCollision, R"doc(Use skin mesh for collision)doc")
        .def_readwrite("skin_offset", &whiteout::m3::ClothPhysics::skinOffset, R"doc(Skin collision offset)doc")
        .def_readwrite("skin_exponent", &whiteout::m3::ClothPhysics::skinExponent, R"doc(Skin collision exponent)doc")
        .def_readwrite("skin_stiffness", &whiteout::m3::ClothPhysics::skinStiffness, R"doc(Skin collision stiffness)doc")
        .def_readwrite("local_channels", &whiteout::m3::ClothPhysics::localChannels, R"doc(Local force channel bitmask)doc")
        .def_readwrite("local_wind", &whiteout::m3::ClothPhysics::localWind, R"doc(Local wind direction and magnitude)doc")
    ;

    py::class_<whiteout::m3::Light>(m, "Light", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("light_type", &whiteout::m3::Light::lightType, R"doc(Light type (omni/spot/directional))doc")
        .def_readwrite("bone_index", &whiteout::m3::Light::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("flags", &whiteout::m3::Light::flags, R"doc(Light flags (shadows, specular, AO, etc.))doc")
        .def_readwrite("lod_cut", &whiteout::m3::Light::lodCut, R"doc(LOD cut-off level)doc")
        .def_readwrite("shadow_lod_cut", &whiteout::m3::Light::shadowLodCut, R"doc(Shadow LOD cut-off level)doc")
        .def_readwrite("diffuse_color", &whiteout::m3::Light::diffuseColor, R"doc(Animated diffuse color (RGB))doc")
        .def_readwrite("intensity_multiplier", &whiteout::m3::Light::intensityMultiplier, R"doc(Animated intensity multiplier)doc")
        .def_readwrite("specular_color", &whiteout::m3::Light::specularColor, R"doc(Animated specular color (RGB))doc")
        .def_readwrite("specular_multiplier", &whiteout::m3::Light::specularMultiplier, R"doc(Animated specular multiplier)doc")
        .def_readwrite("decay", &whiteout::m3::Light::decay, R"doc(Animated distance decay exponent)doc")
        .def_readwrite("attenuation_end", &whiteout::m3::Light::attenuationEnd, R"doc(Attenuation end distance)doc")
        .def_readwrite("attenuation_start", &whiteout::m3::Light::attenuationStart, R"doc(Animated attenuation start distance)doc")
        .def_readwrite("hot_spot", &whiteout::m3::Light::hotSpot, R"doc(Animated spot inner cone angle)doc")
        .def_readwrite("falloff", &whiteout::m3::Light::falloff, R"doc(Animated spot outer cone falloff)doc")
    ;

    py::class_<whiteout::m3::Camera>(m, "Camera", R"doc(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.)doc")
        .def(py::init<>())
        .def_readwrite("bone_index", &whiteout::m3::Camera::boneIndex, R"doc(Index into BONE array)doc")
        .def_readwrite("name", &whiteout::m3::Camera::name, R"doc(Camera name (Ref<CHAR>))doc")
        .def_readwrite("field_of_view", &whiteout::m3::Camera::fieldOfView, R"doc(Animated FOV in radians (v2+))doc")
        .def_readwrite("use_vertical_fov", &whiteout::m3::Camera::useVerticalFOV, R"doc(Use vertical FOV (0 or 1, v2+))doc")
        .def_readwrite("dof_type", &whiteout::m3::Camera::dofType, R"doc(DOF type (v5 only, default 3))doc")
        .def_readwrite("far_clip", &whiteout::m3::Camera::farClip, R"doc(Animated far clip plane (v3+))doc")
        .def_readwrite("near_clip", &whiteout::m3::Camera::nearClip, R"doc(Animated near clip plane (v3+))doc")
        .def_readwrite("shadow_clip_distance", &whiteout::m3::Camera::shadowClipDistance, R"doc(Animated shadow clip distance (v2+))doc")
        .def_readwrite("focus_distance", &whiteout::m3::Camera::focusDistance, R"doc(Animated DOF focal point distance (v2+))doc")
        .def_readwrite("far_focus_range", &whiteout::m3::Camera::farFocusRange, R"doc(Animated DOF far focus range (v2+))doc")
        .def_readwrite("near_focus_range", &whiteout::m3::Camera::nearFocusRange, R"doc(Animated DOF near focus range (v2+))doc")
        .def_readwrite("near_falloff_start", &whiteout::m3::Camera::nearFalloffStart, R"doc(Animated near falloff start (v4+))doc")
        .def_readwrite("near_falloff_end", &whiteout::m3::Camera::nearFalloffEnd, R"doc(Animated near falloff end (v4+))doc")
        .def_readwrite("dof_amount", &whiteout::m3::Camera::dofAmount, R"doc(Animated DOF strength (v2+))doc")
        .def_readwrite("bokeh_f_stop", &whiteout::m3::Camera::bokehFStop, R"doc(Animated bokeh f-stop (v5+))doc")
        .def_readwrite("bokeh_max_co_c_diameter", &whiteout::m3::Camera::bokehMaxCoCDiameter, R"doc(Animated bokeh max CoC diameter (v5+))doc")
    ;

    py::class_<whiteout::m3::Model>(m, "Model", R"doc(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 (+materialAddData): 868 bytes)doc")
        .def(py::init<>())
        .def_readwrite("name", &whiteout::m3::Model::name, R"doc(Model file path (Ref<CHAR>))doc")
        .def_readwrite("flags", &whiteout::m3::Model::flags, R"doc(Model flags (tangents, FOW, instancing, etc.))doc")
        .def_readwrite("sequences", &whiteout::m3::Model::sequences, R"doc(Animation sequences (SEQS))doc")
        .def_readwrite("sub_track_collections", &whiteout::m3::Model::subTrackCollections, R"doc(Sub-track containers (STC_) with keyframe refs)doc")
        .def_readwrite("animation_groups", &whiteout::m3::Model::animationGroups, R"doc(Animation groups (STG_))doc")
        .def_readwrite("bone_animation_sets", &whiteout::m3::Model::boneAnimationSets, R"doc(Bone animation sets (BSET, always null))doc")
        .def_readwrite("animation_split_count", &whiteout::m3::Model::animationSplitCount, R"doc(Always 0)doc")
        .def_readwrite("animation_states", &whiteout::m3::Model::animationStates, R"doc(Animation states (STS_))doc")
        .def_readwrite("bones", &whiteout::m3::Model::bones, R"doc(Skeleton bones (BONE))doc")
        .def_readwrite("skin_bone_count", &whiteout::m3::Model::skinBoneCount, R"doc(Number of bones affecting skin)doc")
        .def_readwrite("divisions", &whiteout::m3::Model::divisions, R"doc(Mesh divisions (DIV_: faces, regions, batches))doc")
        .def_readwrite("bone_lookup", &whiteout::m3::Model::boneLookup, R"doc(Bone index remap table (U16_))doc")
        .def_readwrite("bounds", &whiteout::m3::Model::bounds, R"doc(Model bounding volume)doc")
        .def_readwrite("collision_bounds", &whiteout::m3::Model::collisionBounds, R"doc(Collision bounding volume)doc")
        .def_readwrite("collision_faces", &whiteout::m3::Model::collisionFaces, R"doc(Collision triangle indices (U16_))doc")
        .def_readwrite("collision_verts", &whiteout::m3::Model::collisionVerts, R"doc(Collision vertex positions (VEC3))doc")
        .def_readwrite("collision_normals", &whiteout::m3::Model::collisionNormals, R"doc(Collision face normals (VEC3))doc")
        .def_readwrite("attachment_points", &whiteout::m3::Model::attachmentPoints, R"doc(Named bone locations (ATT_))doc")
        .def_readwrite("attachment_point_addons", &whiteout::m3::Model::attachmentPointAddons, R"doc(Attachment point addon indices (U16_))doc")
        .def_readwrite("lights", &whiteout::m3::Model::lights, R"doc(Lights (LITE))doc")
        .def_readwrite("shadow_boxes", &whiteout::m3::Model::shadowBoxes, R"doc(Shadow boxes (SHBX))doc")
        .def_readwrite("cameras", &whiteout::m3::Model::cameras, R"doc(Cameras (CAM_))doc")
        .def_readwrite("cameras_addons", &whiteout::m3::Model::camerasAddons, R"doc(Camera addon indices (U16_))doc")
        .def_readwrite("material_maps", &whiteout::m3::Model::materialMaps, R"doc(Material type+index maps (MATM))doc")
        .def_readwrite("standard_materials", &whiteout::m3::Model::standardMaterials, R"doc(Standard materials (MAT_))doc")
        .def_readwrite("displacement_materials", &whiteout::m3::Model::displacementMaterials, R"doc(Displacement materials (DIS_))doc")
        .def_readwrite("composite_materials", &whiteout::m3::Model::compositeMaterials, R"doc(Composite materials (CMP_))doc")
        .def_readwrite("terrain_materials", &whiteout::m3::Model::terrainMaterials, R"doc(Terrain materials (TER_))doc")
        .def_readwrite("volume_materials", &whiteout::m3::Model::volumeMaterials, R"doc(Volume materials (VOL_))doc")
        .def_readwrite("hair_materials", &whiteout::m3::Model::hairMaterials, R"doc(Hair materials (HAI_, defunct — always null))doc")
        .def_readwrite("creep_materials", &whiteout::m3::Model::creepMaterials, R"doc(Creep materials (CREP))doc")
        .def_readwrite("volume_noise_materials", &whiteout::m3::Model::volumeNoiseMaterials, R"doc(Volume noise materials (VON_, v25+))doc")
        .def_readwrite("stb_materials", &whiteout::m3::Model::stbMaterials, R"doc(Splat terrain bake materials (STBM, v26+))doc")
        .def_readwrite("reflection_materials", &whiteout::m3::Model::reflectionMaterials, R"doc(Reflection materials (REF_, v28+))doc")
        .def_readwrite("lens_flare_materials", &whiteout::m3::Model::lensFlareMaterials, R"doc(Lens flare materials (LFLR, v29+))doc")
        .def_readwrite("material_add_data", &whiteout::m3::Model::materialAddData, R"doc(Buffer material data (MADD, v30+))doc")
        .def_readwrite("particle_emitters", &whiteout::m3::Model::particleEmitters, R"doc(Particle emitters (PAR_))doc")
        .def_readwrite("particle_emitter_copies", &whiteout::m3::Model::particleEmitterCopies, R"doc(Particle emitter copies (PARC))doc")
        .def_readwrite("ribbon_emitters", &whiteout::m3::Model::ribbonEmitters, R"doc(Ribbon emitters (RIB_))doc")
        .def_readwrite("projections", &whiteout::m3::Model::projections, R"doc(Projectors / decals (PROJ))doc")
        .def_readwrite("forces", &whiteout::m3::Model::forces, R"doc(Forces (FOR_))doc")
        .def_readwrite("warps", &whiteout::m3::Model::warps, R"doc(Warps (WRP_))doc")
        .def_readwrite("view_volumes", &whiteout::m3::Model::viewVolumes, R"doc(View volumes (VVOL))doc")
        .def_readwrite("rigid_bodies", &whiteout::m3::Model::rigidBodies, R"doc(Rigid bodies (PHRB))doc")
        .def_readwrite("physics_constraints", &whiteout::m3::Model::physicsConstraints, R"doc(Physics constraints (PHCT))doc")
        .def_readwrite("physics_joints", &whiteout::m3::Model::physicsJoints, R"doc(Physics joints (PHYJ))doc")
        .def_readwrite("cloth_physics", &whiteout::m3::Model::clothPhysics, R"doc(Cloth physics (PHCL, v28+))doc")
        .def_readwrite("ik_two_joints", &whiteout::m3::Model::ikTwoJoints, R"doc(Two-joint IK solvers (IK2J))doc")
        .def_readwrite("ik_ccd", &whiteout::m3::Model::ikCCD, R"doc(CCD IK solvers (IKCC, v24+))doc")
        .def_readwrite("ik_joints", &whiteout::m3::Model::ikJoints, R"doc(IK joints (IKJT))doc")
        .def_readwrite("one_bone_solvers", &whiteout::m3::Model::oneBoneSolvers, R"doc(One-bone IK solvers (PAOB))doc")
        .def_readwrite("turret_behaviors", &whiteout::m3::Model::turretBehaviors, R"doc(Turret behaviors (PATU))doc")
        .def_readwrite("trigger_data", &whiteout::m3::Model::triggerData, R"doc(Trigger data (TRGD))doc")
        .def_readwrite("initial_reference", &whiteout::m3::Model::initialReference, R"doc(Inverse bind-pose matrices (IREF))doc")
        .def_readwrite("tight_hit_test_object", &whiteout::m3::Model::tightHitTestObject, R"doc(Tight hit-test shape (SSGS, inline))doc")
        .def_readwrite("fuzzy_hit_test_objects", &whiteout::m3::Model::fuzzyHitTestObjects, R"doc(Fuzzy hit-test shapes (SSGS))doc")
        .def_readwrite("attachment_volumes", &whiteout::m3::Model::attachmentVolumes, R"doc(Attachment volumes (ATVL))doc")
        .def_readwrite("attachment_volumes_addon0", &whiteout::m3::Model::attachmentVolumesAddon0, R"doc(Attachment volume addon 0 (U16_))doc")
        .def_readwrite("attachment_volumes_addon1", &whiteout::m3::Model::attachmentVolumesAddon1, R"doc(Attachment volume addon 1 (U16_))doc")
        .def_readwrite("billboard_behaviors", &whiteout::m3::Model::billboardBehaviors, R"doc(Billboard behaviors (BBSC))doc")
        .def_readwrite("trailing_models", &whiteout::m3::Model::trailingModels, R"doc(Trailing models (TMD_, defunct))doc")
        .def_readwrite("m3a_anim_hash", &whiteout::m3::Model::m3aAnimHash, R"doc(Hash for .m3a animation file binding)doc")
        .def_readwrite("m3a_anim_hashes", &whiteout::m3::Model::m3aAnimHashes, R"doc(Additional .m3a hashes (U32_))doc")
    ;

    py::class_<whiteout::m3::Parser>(m, "Parser", R"doc(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.)doc")
        .def(py::init<>())
        .def("parse", py::overload_cast<const std::string&>(&whiteout::m3::Parser::parse), py::arg("filePath"), R"doc(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)doc")
        .def("parse",
            [](whiteout::m3::Parser& self, py::bytes __py_bytes_0) {
                std::string __s_0 = __py_bytes_0;
                std::span<const whiteout::u8> buffer(reinterpret_cast<const whiteout::u8*>(__s_0.data()), __s_0.size());
                return self.parse(buffer);
            }, py::arg("buffer"), R"doc(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)doc")
        .def("has_issues", &whiteout::m3::Parser::hasIssues, R"doc(Check if parsing encountered any issues @return True if there were warnings or recoverable errors)doc")
        .def("get_issues", &whiteout::m3::Parser::getIssues, R"doc(Get list of issues encountered during parsing @return Vector of issue description strings)doc")
    ;

    py::class_<whiteout::m3::Writer>(m, "Writer", R"doc(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.)doc")
        .def(py::init<>())
        .def("write", py::overload_cast<const std::string&, const whiteout::m3::Model&>(&whiteout::m3::Writer::write), py::arg("filePath"), py::arg("model"), R"doc(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)doc")
        .def("write",
            [](whiteout::m3::Writer& self, const whiteout::m3::Model& model) {
                auto __v = self.write(model);
                return py::bytes(
                    reinterpret_cast<const char*>(__v.data()), __v.size());
            }, py::arg("model"), R"doc(Write an M3 model to a byte buffer @param model Model data to serialize @return Byte buffer containing the M3 file data)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::f32>>(m, "AnimRefF32", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::f32>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::f32>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::f32>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::f32>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::f32>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::f32>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::Vector3f>>(m, "AnimRefVector3f", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::Vector3f>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::Vector3f>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::Vector3f>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::Vector3f>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::Vector3f>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::Vector3f>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>>(m, "AnimRefM3ColorBGRA", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::m3::ColorBGRA>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::u16>>(m, "AnimRefU16", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::u16>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::u16>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::u16>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::u16>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::u16>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::u16>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::Vector2f>>(m, "AnimRefVector2f", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::Vector2f>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::Vector2f>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::Vector2f>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::Vector2f>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::Vector2f>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::Vector2f>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::u32>>(m, "AnimRefU32", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::u32>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::u32>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::u32>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::u32>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::u32>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::u32>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::Quaternion>>(m, "AnimRefQuaternion", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::Quaternion>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::Quaternion>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::Quaternion>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::Quaternion>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::Quaternion>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::Quaternion>::unused, R"doc(Typically -1)doc")
    ;

    py::class_<whiteout::m3::AnimRef<whiteout::m3::Extent>>(m, "AnimRefM3Extent", R"doc(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.))doc")
        .def(py::init<>())
        .def_readwrite("interp_type", &whiteout::m3::AnimRef<whiteout::m3::Extent>::interpType, R"doc(Interpolation: 0=none/step, 1=linear, 2=hermite, 3=bezier)doc")
        .def_readwrite("flags", &whiteout::m3::AnimRef<whiteout::m3::Extent>::flags, R"doc(Animation flags)doc")
        .def_readwrite("anim_id", &whiteout::m3::AnimRef<whiteout::m3::Extent>::animId, R"doc(Animation identifier (links to STC animation data; 0=not animated))doc")
        .def_readwrite("init_value", &whiteout::m3::AnimRef<whiteout::m3::Extent>::initValue, R"doc(Initial/default value (used when not animated))doc")
        .def_readwrite("null_value", &whiteout::m3::AnimRef<whiteout::m3::Extent>::nullValue, R"doc(Null/reset value)doc")
        .def_readwrite("unused", &whiteout::m3::AnimRef<whiteout::m3::Extent>::unused, R"doc(Typically -1)doc")
    ;

    py::bind_vector<std::vector<whiteout::u64>>(m, "VectorU64", py::buffer_protocol());
    py::bind_vector<std::vector<whiteout::m3::AnimRef<whiteout::f32>>>(m, "VectorM3AnimRefF32");
    py::bind_vector<std::vector<whiteout::m3::AnimRef<whiteout::Vector3f>>>(m, "VectorM3AnimRefVector3f");
    py::bind_vector<std::vector<whiteout::m3::AnimationGroup>>(m, "VectorM3AnimationGroup");
    py::bind_vector<std::vector<whiteout::m3::AnimationState>>(m, "VectorM3AnimationState");
    py::bind_vector<std::vector<whiteout::m3::AttachmentPoint>>(m, "VectorM3AttachmentPoint");
    py::bind_vector<std::vector<whiteout::m3::AttachmentVolume>>(m, "VectorM3AttachmentVolume");
    py::bind_vector<std::vector<whiteout::m3::Batch>>(m, "VectorM3Batch");
    py::bind_vector<std::vector<whiteout::m3::BillboardBehavior>>(m, "VectorM3BillboardBehavior");
    py::bind_vector<std::vector<whiteout::m3::Bone>>(m, "VectorM3Bone");
    py::bind_vector<std::vector<whiteout::m3::BoneAnimationSet>>(m, "VectorM3BoneAnimationSet");
    py::bind_vector<std::vector<whiteout::m3::Camera>>(m, "VectorM3Camera");
    py::bind_vector<std::vector<whiteout::m3::ClothCollider>>(m, "VectorM3ClothCollider");
    py::bind_vector<std::vector<whiteout::m3::ClothPhysics>>(m, "VectorM3ClothPhysics");
    py::bind_vector<std::vector<whiteout::m3::ClothProxy>>(m, "VectorM3ClothProxy");
    py::bind_vector<std::vector<whiteout::m3::CompositeMaterial>>(m, "VectorM3CompositeMaterial");
    py::bind_vector<std::vector<whiteout::m3::CompositeSection>>(m, "VectorM3CompositeSection");
    py::bind_vector<std::vector<whiteout::m3::ConvexHullHalfEdge>>(m, "VectorM3ConvexHullHalfEdge");
    py::bind_vector<std::vector<whiteout::m3::CreepMaterial>>(m, "VectorM3CreepMaterial");
    py::bind_vector<std::vector<whiteout::m3::DisplacementMaterial>>(m, "VectorM3DisplacementMaterial");
    py::bind_vector<std::vector<whiteout::m3::Force>>(m, "VectorM3Force");
    py::bind_vector<std::vector<whiteout::m3::HairMaterial>>(m, "VectorM3HairMaterial");
    py::bind_vector<std::vector<whiteout::m3::HitTestShape>>(m, "VectorM3HitTestShape");
    py::bind_vector<std::vector<whiteout::m3::IKCCD>>(m, "VectorM3IKCCD");
    py::bind_vector<std::vector<whiteout::m3::IKJoint>>(m, "VectorM3IKJoint");
    py::bind_vector<std::vector<whiteout::m3::IKTwoJoint>>(m, "VectorM3IKTwoJoint");
    py::bind_vector<std::vector<whiteout::m3::InitialReference>>(m, "VectorM3InitialReference");
    py::bind_vector<std::vector<whiteout::m3::LensFlare>>(m, "VectorM3LensFlare");
    py::bind_vector<std::vector<whiteout::m3::Light>>(m, "VectorM3Light");
    py::bind_vector<std::vector<whiteout::m3::MaterialAddData>>(m, "VectorM3MaterialAddData");
    py::bind_vector<std::vector<whiteout::m3::MaterialMap>>(m, "VectorM3MaterialMap");
    py::bind_vector<std::vector<whiteout::m3::MeshDivision>>(m, "VectorM3MeshDivision");
    py::bind_vector<std::vector<whiteout::m3::MeshSection>>(m, "VectorM3MeshSection");
    py::bind_vector<std::vector<whiteout::m3::OneBoneSolver>>(m, "VectorM3OneBoneSolver");
    py::bind_vector<std::vector<whiteout::m3::ParticleEmitter>>(m, "VectorM3ParticleEmitter");
    py::bind_vector<std::vector<whiteout::m3::ParticleEmitterCopy>>(m, "VectorM3ParticleEmitterCopy");
    py::bind_vector<std::vector<whiteout::m3::PhysicsConstraint>>(m, "VectorM3PhysicsConstraint");
    py::bind_vector<std::vector<whiteout::m3::PhysicsJoint>>(m, "VectorM3PhysicsJoint");
    py::bind_vector<std::vector<whiteout::m3::PhysicsMeshBvhNode>>(m, "VectorM3PhysicsMeshBvhNode");
    py::bind_vector<std::vector<whiteout::m3::PhysicsShape>>(m, "VectorM3PhysicsShape");
    py::bind_vector<std::vector<whiteout::m3::Projector>>(m, "VectorM3Projector");
    py::bind_vector<std::vector<whiteout::m3::ReflectionMaterial>>(m, "VectorM3ReflectionMaterial");
    py::bind_vector<std::vector<whiteout::m3::Region>>(m, "VectorM3Region");
    py::bind_vector<std::vector<whiteout::m3::RibbonEmitter>>(m, "VectorM3RibbonEmitter");
    py::bind_vector<std::vector<whiteout::m3::RigidBody>>(m, "VectorM3RigidBody");
    py::bind_vector<std::vector<whiteout::m3::STBMaterial>>(m, "VectorM3STBMaterial");
    py::bind_vector<std::vector<whiteout::m3::Sequence>>(m, "VectorM3Sequence");
    py::bind_vector<std::vector<whiteout::m3::ShadowBox>>(m, "VectorM3ShadowBox");
    py::bind_vector<std::vector<whiteout::m3::SplineRibbon>>(m, "VectorM3SplineRibbon");
    py::bind_vector<std::vector<whiteout::m3::StandardMaterial>>(m, "VectorM3StandardMaterial");
    py::bind_vector<std::vector<whiteout::m3::SubFlare>>(m, "VectorM3SubFlare");
    py::bind_vector<std::vector<whiteout::m3::SubTrackContainer>>(m, "VectorM3SubTrackContainer");
    py::bind_vector<std::vector<whiteout::m3::TerrainMaterial>>(m, "VectorM3TerrainMaterial");
    py::bind_vector<std::vector<whiteout::m3::TrailingModel>>(m, "VectorM3TrailingModel");
    py::bind_vector<std::vector<whiteout::m3::TriggerData>>(m, "VectorM3TriggerData");
    py::bind_vector<std::vector<whiteout::m3::TurretBehavior>>(m, "VectorM3TurretBehavior");
    py::bind_vector<std::vector<whiteout::m3::ViewVolume>>(m, "VectorM3ViewVolume");
    py::bind_vector<std::vector<whiteout::m3::VolumeMaterial>>(m, "VectorM3VolumeMaterial");
    py::bind_vector<std::vector<whiteout::m3::VolumeNoiseMaterial>>(m, "VectorM3VolumeNoiseMaterial");
    py::bind_vector<std::vector<whiteout::m3::Warp>>(m, "VectorM3Warp");

}