m2_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 m2 --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/m2/types.h>
#include <whiteout/models/m2/structures/base.h>
#include <whiteout/models/m2/structures/extensions.h>
#include <whiteout/models/m2/structures/phys.h>
#include <whiteout/models/m2/structures/bone_overrides.h>
#include <whiteout/models/m2/structures/skin.h>
#include <whiteout/models/m2/structures.h>
#include <whiteout/models/m2/parser.h>
#include <whiteout/models/m2/phys_file.h>
#include <whiteout/models/m2/bone_file.h>
#include <whiteout/models/m2/writer.h>
#include <whiteout/interfaces.h>

PYBIND11_MAKE_OPAQUE(std::vector<whiteout::i16>);
PYBIND11_MAKE_OPAQUE(std::vector<std::string>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::u32>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::Quaternion>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::Vector3f>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::f32>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::i16>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::m2::CameraSpline>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::m2::CompatQuaternion>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::u16>>);
PYBIND11_MAKE_OPAQUE(std::vector<std::vector<whiteout::u8>>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u8>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u32>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::u16>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Quaternion>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector2f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector3f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector4f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::f32>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::AnimationTrackBase>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Attachment>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Batch>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Bone>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::BoneOverride>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::BoneOverrideSet>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::BoxShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Camera>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::CameraSpline>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::CapsuleShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ColorAnimation>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::CompatQuaternion>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::DebugOcclusionData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::DetailedLightData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::DistanceFadeData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::DistanceJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::EdgeFadeData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Event>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Extent>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::GlobalSequence>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Light>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Material>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ParticleEmitter>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ParticleGeosetData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PhysicsBody>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PhysicsJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PhysicsShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PhysicsTuning>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PivotDisplacementData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PolytopeHalfEdge>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PolytopeShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::PrismaticJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::RevoluteJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::RibbonEmitter>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Sequence>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ShadowBatch>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ShoulderJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SkinProfile>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SkinSection>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SphereShape>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SphericalJoint>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Texture>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::TextureTransform>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::TextureWeight>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::TexturedLightData>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Vertex>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::WeldJoint>);

#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_m2(py::module_& m) {
    py::enum_<whiteout::m2::InterpolationType>(m, "InterpolationType")
        .value("NONE", whiteout::m2::InterpolationType::None)
        .value("LINEAR", whiteout::m2::InterpolationType::Linear)
        .value("BEZIER", whiteout::m2::InterpolationType::Bezier)
        .value("HERMITE", whiteout::m2::InterpolationType::Hermite)
    ;

    py::enum_<whiteout::m2::GlobalFlag>(m, "GlobalFlag")
        .value("NONE", whiteout::m2::GlobalFlag::None)
        .value("TILT_X", whiteout::m2::GlobalFlag::TiltX)
        .value("TILT_Y", whiteout::m2::GlobalFlag::TiltY)
        .value("ADD_BACK_REFERENCES", whiteout::m2::GlobalFlag::AddBackReferences)
        .value("USE_TEXTURE_COMBINER_COMBOS", whiteout::m2::GlobalFlag::UseTextureCombinerCombos)
        .value("IS_CAMERA", whiteout::m2::GlobalFlag::IsCamera)
        .value("LOAD_PHYSICS_DATA", whiteout::m2::GlobalFlag::LoadPhysicsData)
        .value("UNK_0X80", whiteout::m2::GlobalFlag::Unk_0x80)
        .value("UNK_0X100", whiteout::m2::GlobalFlag::Unk_0x100)
        .value("NEW_PARTICLE_RECORD", whiteout::m2::GlobalFlag::NewParticleRecord)
        .value("UNK_0X400", whiteout::m2::GlobalFlag::Unk_0x400)
        .value("TEXTURE_TRANSFORMS_USES_BONE_SEQUENCES", whiteout::m2::GlobalFlag::TextureTransformsUsesBoneSequences)
        .value("UNK_0X1000", whiteout::m2::GlobalFlag::Unk_0x1000)
        .value("CHUNKED_ANIM_FILES", whiteout::m2::GlobalFlag::ChunkedAnimFiles)
        .value("UPGRADED_FORMAT", whiteout::m2::GlobalFlag::UpgradedFormat)
    ;

    py::enum_<whiteout::m2::SequenceFlag>(m, "SequenceFlag")
        .value("NONE", whiteout::m2::SequenceFlag::None)
        .value("TILT_IN", whiteout::m2::SequenceFlag::TiltIn)
        .value("TILT_OUT", whiteout::m2::SequenceFlag::TiltOut)
        .value("TILT_FIXED", whiteout::m2::SequenceFlag::TiltFixed)
        .value("LOOPING", whiteout::m2::SequenceFlag::Looping)
        .value("IS_ALIAS", whiteout::m2::SequenceFlag::IsAlias)
        .value("ANIMATED_SETUP", whiteout::m2::SequenceFlag::AnimatedSetup)
        .value("STORED_ANIMATED", whiteout::m2::SequenceFlag::StoredAnimated)
        .value("ENABLE_COMPOSITE", whiteout::m2::SequenceFlag::EnableComposite)
    ;

    py::enum_<whiteout::m2::BoneFlag>(m, "BoneFlag")
        .value("NONE", whiteout::m2::BoneFlag::None)
        .value("IGNORE_PARENT_TRANSLATE", whiteout::m2::BoneFlag::IgnoreParentTranslate)
        .value("IGNORE_PARENT_SCALE", whiteout::m2::BoneFlag::IgnoreParentScale)
        .value("IGNORE_PARENT_ROTATION", whiteout::m2::BoneFlag::IgnoreParentRotation)
        .value("SPHERICAL_BILLBOARD", whiteout::m2::BoneFlag::SphericalBillboard)
        .value("CYLINDRICAL_BILLBOARD_X", whiteout::m2::BoneFlag::CylindricalBillboardX)
        .value("CYLINDRICAL_BILLBOARD_Y", whiteout::m2::BoneFlag::CylindricalBillboardY)
        .value("CYLINDRICAL_BILLBOARD_Z", whiteout::m2::BoneFlag::CylindricalBillboardZ)
        .value("TRANSFORMED", whiteout::m2::BoneFlag::Transformed)
        .value("KINEMATIC", whiteout::m2::BoneFlag::Kinematic)
        .value("HELMET_ANIM_SCALED", whiteout::m2::BoneFlag::HelmetAnimScaled)
    ;

    py::enum_<whiteout::m2::MaterialFlag>(m, "MaterialFlag")
        .value("NONE", whiteout::m2::MaterialFlag::None)
        .value("UNLIT", whiteout::m2::MaterialFlag::Unlit)
        .value("UNFOGGED", whiteout::m2::MaterialFlag::Unfogged)
        .value("TWO_SIDED", whiteout::m2::MaterialFlag::TwoSided)
        .value("DEPTH_TEST", whiteout::m2::MaterialFlag::DepthTest)
        .value("DEPTH_WRITE", whiteout::m2::MaterialFlag::DepthWrite)
        .value("NO_ALPHA_COMPOSITE", whiteout::m2::MaterialFlag::NoAlphaComposite)
    ;

    py::enum_<whiteout::m2::ParticleEmitterType>(m, "ParticleEmitterType")
        .value("PLANE", whiteout::m2::ParticleEmitterType::Plane)
        .value("SPHERE", whiteout::m2::ParticleEmitterType::Sphere)
        .value("SPLINE", whiteout::m2::ParticleEmitterType::Spline)
        .value("BONE", whiteout::m2::ParticleEmitterType::Bone)
    ;

    py::enum_<whiteout::m2::ParticleBlending>(m, "ParticleBlending")
        .value("OPAQUE", whiteout::m2::ParticleBlending::Opaque)
        .value("ALPHA_BLEND", whiteout::m2::ParticleBlending::AlphaBlend)
        .value("ADDITIVE", whiteout::m2::ParticleBlending::Additive)
        .value("ALPHA_TEST", whiteout::m2::ParticleBlending::AlphaTest)
        .value("ADDITIVE_ALPHA_TEST", whiteout::m2::ParticleBlending::AdditiveAlphaTest)
    ;

    py::enum_<whiteout::m2::ParticleFlag>(m, "ParticleFlag")
        .value("NONE", whiteout::m2::ParticleFlag::None)
        .value("UNLIT", whiteout::m2::ParticleFlag::Unlit)
        .value("SORT_PARTICLES", whiteout::m2::ParticleFlag::SortParticles)
        .value("VELOCITY_ORIENT", whiteout::m2::ParticleFlag::VelocityOrient)
        .value("UNFOGGED", whiteout::m2::ParticleFlag::Unfogged)
        .value("WORLD_SPACE", whiteout::m2::ParticleFlag::WorldSpace)
        .value("INHERIT_BONE_SCALE", whiteout::m2::ParticleFlag::InheritBoneScale)
        .value("INHERIT_VELOCITY", whiteout::m2::ParticleFlag::InheritVelocity)
        .value("IMPLOSION_FILTER", whiteout::m2::ParticleFlag::ImplosionFilter)
        .value("HEMISPHERE_UP_DIRECTION", whiteout::m2::ParticleFlag::HemisphereUpDirection)
        .value("NEGATE_SPIN_RANDOM", whiteout::m2::ParticleFlag::NegateSpinRandom)
        .value("CLAMP_TAIL_TO_AGE", whiteout::m2::ParticleFlag::ClampTailToAge)
        .value("INHERIT_POSITION", whiteout::m2::ParticleFlag::InheritPosition)
        .value("XY_QUAD", whiteout::m2::ParticleFlag::XYQuad)
        .value("PROJECT_PARTICLE", whiteout::m2::ParticleFlag::ProjectParticle)
        .value("FOLLOW_POSITION", whiteout::m2::ParticleFlag::FollowPosition)
        .value("SQUIRT", whiteout::m2::ParticleFlag::Squirt)
        .value("CHOOSE_RANDOM_TEXTURE", whiteout::m2::ParticleFlag::ChooseRandomTexture)
        .value("HEAD_STYLE", whiteout::m2::ParticleFlag::HeadStyle)
        .value("TAIL_STYLE", whiteout::m2::ParticleFlag::TailStyle)
        .value("UNSCALED_SIZE_VARIATION", whiteout::m2::ParticleFlag::UnscaledSizeVariation)
        .value("REFRACTION", whiteout::m2::ParticleFlag::Refraction)
        .value("RAND_FLIPBOOK_START", whiteout::m2::ParticleFlag::RandFlipbookStart)
        .value("UNK_0X400000", whiteout::m2::ParticleFlag::Unk_0x400000)
        .value("COMPRESSED_GRAVITY", whiteout::m2::ParticleFlag::CompressedGravity)
        .value("BONE_GENERATOR_BONE", whiteout::m2::ParticleFlag::BoneGeneratorBone)
        .value("NO_GLOBAL_VIEW_SCALE", whiteout::m2::ParticleFlag::NoGlobalViewScale)
        .value("LOD_IGNORE_DISTANCE", whiteout::m2::ParticleFlag::LodIgnoreDistance)
        .value("OFFSET_HEAD_BY_SPIN", whiteout::m2::ParticleFlag::OffsetHeadBySpin)
        .value("MULTI_TEXTURE", whiteout::m2::ParticleFlag::MultiTexture)
        .value("MULTITEX_USE_MODX4", whiteout::m2::ParticleFlag::MultitexUseModx4)
        .value("MULTITEX_USE3_COLORS", whiteout::m2::ParticleFlag::MultitexUse3Colors)
        .value("DYNAMIC_WIND", whiteout::m2::ParticleFlag::DynamicWind)
    ;

    py::enum_<whiteout::m2::PhysicsBodyType>(m, "PhysicsBodyType", R"doc(How the client drives a body — the value stored in BODY is inverted relative to Domino's own `dmBodyType`.)doc")
        .value("KINEMATIC", whiteout::m2::PhysicsBodyType::Kinematic, R"doc(Animation-driven collider. Becomes `dmBodyType` 1; the client keeps it glued to its bone and the simulation only reads it.)doc")
        .value("DYNAMIC", whiteout::m2::PhysicsBodyType::Dynamic, R"doc(Simulated. Becomes `dmBodyType` 0 and gets its bone transform written back every frame. These are the cloth/tassel segments.)doc")
    ;

    py::enum_<whiteout::m2::PhysicsShapeType>(m, "PhysicsShapeType", R"doc(Which shape chunk a PhysicsShape indexes into.)doc")
        .value("BOX", whiteout::m2::PhysicsShapeType::Box, R"doc(BOXS)doc")
        .value("CAPSULE", whiteout::m2::PhysicsShapeType::Capsule, R"doc(CAPS)doc")
        .value("SPHERE", whiteout::m2::PhysicsShapeType::Sphere, R"doc(SPHS)doc")
        .value("POLYTOPE", whiteout::m2::PhysicsShapeType::Polytope, R"doc(PLYT, version 3+)doc")
    ;

    py::enum_<whiteout::m2::PhysicsJointType>(m, "PhysicsJointType", R"doc(Which joint chunk a PhysicsJoint indexes into.)doc")
        .value("SPHERICAL", whiteout::m2::PhysicsJointType::Spherical, R"doc(SPHJ)doc")
        .value("SHOULDER", whiteout::m2::PhysicsJointType::Shoulder, R"doc(SHOJ / SHJ2)doc")
        .value("WELD", whiteout::m2::PhysicsJointType::Weld, R"doc(WELJ / WLJ2 / WLJ3)doc")
        .value("REVOLUTE", whiteout::m2::PhysicsJointType::Revolute, R"doc(REVJ / REV2, version 2+)doc")
        .value("PRISMATIC", whiteout::m2::PhysicsJointType::Prismatic, R"doc(PRSJ / PRS2, version 2+)doc")
        .value("DISTANCE", whiteout::m2::PhysicsJointType::Distance, R"doc(DSTJ, version 2+)doc")
    ;

    py::class_<whiteout::m2::Extent>(m, "Extent")
        .def(py::init<>())
        .def_readwrite("minimum", &whiteout::m2::Extent::minimum)
        .def_readwrite("maximum", &whiteout::m2::Extent::maximum)
        .def_readwrite("sphere_radius", &whiteout::m2::Extent::sphereRadius)
    ;

    py::class_<whiteout::m2::PhysicsFrame>(m, "PhysicsFrame", R"doc(The affine frame the Domino chunks store: three basis columns and an origin, twelve floats in all.

The client reassembles it as `dmMtx{axisX, axisY, axisZ}` -> `dmQuatFromMtx` plus `origin` as the translation, giving a `dmTransform`.)doc")
        .def(py::init<>())
        .def_readwrite("axis_x", &whiteout::m2::PhysicsFrame::axisX)
        .def_readwrite("axis_y", &whiteout::m2::PhysicsFrame::axisY)
        .def_readwrite("axis_z", &whiteout::m2::PhysicsFrame::axisZ)
        .def_readwrite("origin", &whiteout::m2::PhysicsFrame::origin)
    ;

    py::class_<whiteout::m2::CompatQuaternion>(m, "CompatQuaternion")
        .def(py::init<>())
    ;

    py::class_<whiteout::m2::ColorBGRA>(m, "ColorBGRA")
        .def(py::init<>())
    ;

    py::class_<whiteout::m2::KeySpanRef>(m, "KeySpanRef", R"doc(One sequence's slice of a key array, as the file writes it: a count and an offset into whichever file holds that sequence's keys.

Kept only by a lazily parsed model (Parser::setLazyAnimations), which leaves the sub-arrays of externally-stored sequences empty until loadSequence() reads their `.anim` sibling. Nothing else needs it: an eager parse consumes the reference on the spot.)doc")
        .def(py::init<>())
        .def_readwrite("count", &whiteout::m2::KeySpanRef::count)
        .def_readwrite("offset", &whiteout::m2::KeySpanRef::offset)
    ;

    py::class_<whiteout::m2::AnimationTrackBase>(m, "AnimationTrackBase")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrackBase::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrackBase::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrackBase::timestamps)
    ;

    py::class_<whiteout::m2::ParticleEmitterExtension>(m, "ParticleEmitterExtension")
        .def(py::init<>())
        .def_readwrite("z_source", &whiteout::m2::ParticleEmitterExtension::zSource)
        .def_readwrite("color_mult", &whiteout::m2::ParticleEmitterExtension::colorMult)
        .def_readwrite("alpha_mult", &whiteout::m2::ParticleEmitterExtension::alphaMult)
    ;

    py::class_<whiteout::m2::LodProfile>(m, "LodProfile")
        .def(py::init<>())
        .def_readwrite("flags", &whiteout::m2::LodProfile::flags)
        .def_readwrite("num_lod_levels", &whiteout::m2::LodProfile::numLodLevels)
        .def_readwrite("lod_distance", &whiteout::m2::LodProfile::lodDistance)
        .def_readwrite("lod_scale_raw", &whiteout::m2::LodProfile::lodScaleRaw, R"doc(Fixed-point LOD scale, applied as `lodScaleRaw / 2048.0` and only when `flags & 0x08` is set (otherwise the client uses 1.0). This is the pair of bytes previously read as `reserved0` + `lodFlags`; reading it as a u16 explains why the high byte looked like a mirror of flags bit 3, since 0x0800 / 2048 == 1.0.)doc")
        .def_readwrite("lod_batch_count", &whiteout::m2::LodProfile::lodBatchCount)
        .def_readwrite("reserved1", &whiteout::m2::LodProfile::reserved1)
        .def("get_particle_bone_lod",
            [](const whiteout::m2::LodProfile& self) {
                return std::vector<whiteout::u8>(self.particleBoneLod.begin(), self.particleBoneLod.end());
            })
        .def("set_particle_bone_lod",
            [](whiteout::m2::LodProfile& self, const std::vector<whiteout::u8>& v) {
                if (v.size() != self.particleBoneLod.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.particleBoneLod.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.particleBoneLod[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::WaterfallData>(m, "WaterfallData")
        .def(py::init<>())
        .def_readwrite("bump_scale", &whiteout::m2::WaterfallData::bumpScale)
        .def_readwrite("value0_x", &whiteout::m2::WaterfallData::value0_x)
        .def_readwrite("value0_y", &whiteout::m2::WaterfallData::value0_y)
        .def_readwrite("value0_z", &whiteout::m2::WaterfallData::value0_z)
        .def_readwrite("value1_w", &whiteout::m2::WaterfallData::value1_w)
        .def_readwrite("value0_w", &whiteout::m2::WaterfallData::value0_w)
        .def_readwrite("value1_x", &whiteout::m2::WaterfallData::value1_x)
        .def_readwrite("value1_y", &whiteout::m2::WaterfallData::value1_y)
        .def_readwrite("value2_w", &whiteout::m2::WaterfallData::value2_w)
        .def_readwrite("value3_y", &whiteout::m2::WaterfallData::value3_y)
        .def_readwrite("value3_x", &whiteout::m2::WaterfallData::value3_x)
        .def_readwrite("base_color", &whiteout::m2::WaterfallData::baseColor)
        .def_readwrite("flags", &whiteout::m2::WaterfallData::flags)
        .def_readwrite("unknown0", &whiteout::m2::WaterfallData::unknown0)
        .def_readwrite("value3_w", &whiteout::m2::WaterfallData::value3_w)
        .def_readwrite("value3_z", &whiteout::m2::WaterfallData::value3_z)
        .def_readwrite("value4_y", &whiteout::m2::WaterfallData::value4_y)
        .def_readwrite("unknown1", &whiteout::m2::WaterfallData::unknown1)
        .def_readwrite("unknown2", &whiteout::m2::WaterfallData::unknown2)
        .def_readwrite("unknown3", &whiteout::m2::WaterfallData::unknown3)
        .def_readwrite("unknown4", &whiteout::m2::WaterfallData::unknown4)
    ;

    py::class_<whiteout::m2::ParticleGeosetData>(m, "ParticleGeosetData")
        .def(py::init<>())
        .def_readwrite("geoset", &whiteout::m2::ParticleGeosetData::geoset)
    ;

    py::class_<whiteout::m2::EdgeFadeData>(m, "EdgeFadeData")
        .def(py::init<>())
        .def_readwrite("value8", &whiteout::m2::EdgeFadeData::value8)
        .def("get_value0",
            [](const whiteout::m2::EdgeFadeData& self) {
                return std::vector<whiteout::f32>(self.value0.begin(), self.value0.end());
            })
        .def("set_value0",
            [](whiteout::m2::EdgeFadeData& self, const std::vector<whiteout::f32>& v) {
                if (v.size() != self.value0.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.value0.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.value0[i] = v[i];
            })
        .def("get_value_c",
            [](const whiteout::m2::EdgeFadeData& self) {
                return std::vector<whiteout::u8>(self.valueC.begin(), self.valueC.end());
            })
        .def("set_value_c",
            [](whiteout::m2::EdgeFadeData& self, const std::vector<whiteout::u8>& v) {
                if (v.size() != self.valueC.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.valueC.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.valueC[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::DistanceFadeData>(m, "DistanceFadeData")
        .def(py::init<>())
        .def_readwrite("squared_far_dist", &whiteout::m2::DistanceFadeData::squaredFarDist)
        .def_readwrite("squared_near_dist", &whiteout::m2::DistanceFadeData::squaredNearDist)
        .def("get_reserved",
            [](const whiteout::m2::DistanceFadeData& self) {
                return std::vector<whiteout::u32>(self.reserved.begin(), self.reserved.end());
            })
        .def("set_reserved",
            [](whiteout::m2::DistanceFadeData& self, const std::vector<whiteout::u32>& 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::m2::DetailedLightData>(m, "DetailedLightData")
        .def(py::init<>())
        .def_readwrite("flags", &whiteout::m2::DetailedLightData::flags)
        .def_readwrite("unknown0", &whiteout::m2::DetailedLightData::unknown0)
        .def_readwrite("unknown1", &whiteout::m2::DetailedLightData::unknown1)
    ;

    py::class_<whiteout::m2::DebugOcclusionData>(m, "DebugOcclusionData")
        .def(py::init<>())
        .def_readwrite("unknown1_1", &whiteout::m2::DebugOcclusionData::unknown1_1)
        .def_readwrite("unknown1_2", &whiteout::m2::DebugOcclusionData::unknown1_2)
        .def_readwrite("unknown1_3", &whiteout::m2::DebugOcclusionData::unknown1_3)
        .def_readwrite("unknown1_4", &whiteout::m2::DebugOcclusionData::unknown1_4)
    ;

    py::class_<whiteout::m2::TexturedLightData>(m, "TexturedLightData")
        .def(py::init<>())
        .def_readwrite("unknown0", &whiteout::m2::TexturedLightData::unknown0)
        .def_readwrite("unknown1", &whiteout::m2::TexturedLightData::unknown1)
        .def_readwrite("texture_lookup", &whiteout::m2::TexturedLightData::textureLookup)
        .def_readwrite("unknown2", &whiteout::m2::TexturedLightData::unknown2)
    ;

    py::class_<whiteout::m2::PivotDisplacementData>(m, "PivotDisplacementData", R"doc(One DPIV (pivot displacement) record, 32 bytes.

The client keeps the payload pointer and a record count of `chunkSize / 32`, so a chunk holds N of these — the corpus has both 1- and 2-record chunks.)doc")
        .def(py::init<>())
        .def_readwrite("offset", &whiteout::m2::PivotDisplacementData::offset, R"doc(small displacement; Z varies most)doc")
        .def_readwrite("flags", &whiteout::m2::PivotDisplacementData::flags, R"doc(0 or 1)doc")
        .def("get_reserved",
            [](const whiteout::m2::PivotDisplacementData& self) {
                return std::vector<whiteout::u32>(self.reserved.begin(), self.reserved.end());
            })
        .def("set_reserved",
            [](whiteout::m2::PivotDisplacementData& self, const std::vector<whiteout::u32>& 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::m2::PhysicsCollision>(m, "PhysicsCollision")
        .def(py::init<>())
        .def_readwrite("vertex_positions", &whiteout::m2::PhysicsCollision::vertexPositions)
        .def_readwrite("face_normals", &whiteout::m2::PhysicsCollision::faceNormals)
        .def_readwrite("indices", &whiteout::m2::PhysicsCollision::indices)
        .def_readwrite("flags", &whiteout::m2::PhysicsCollision::flags)
    ;

    py::class_<whiteout::m2::SkinSection>(m, "SkinSection")
        .def(py::init<>())
        .def_readwrite("skin_section_id", &whiteout::m2::SkinSection::skinSectionId)
        .def_readwrite("level", &whiteout::m2::SkinSection::level)
        .def_readwrite("vertex_start", &whiteout::m2::SkinSection::vertexStart)
        .def_readwrite("vertex_count", &whiteout::m2::SkinSection::vertexCount)
        .def_readwrite("index_start", &whiteout::m2::SkinSection::indexStart)
        .def_readwrite("index_count", &whiteout::m2::SkinSection::indexCount)
        .def_readwrite("bone_count", &whiteout::m2::SkinSection::boneCount)
        .def_readwrite("bone_combo_index", &whiteout::m2::SkinSection::boneComboIndex)
        .def_readwrite("bone_influences", &whiteout::m2::SkinSection::boneInfluences)
        .def_readwrite("center_bone_index", &whiteout::m2::SkinSection::centerBoneIndex)
        .def_readwrite("center_position", &whiteout::m2::SkinSection::centerPosition)
        .def_readwrite("sort_center_position", &whiteout::m2::SkinSection::sortCenterPosition)
        .def_readwrite("sort_radius", &whiteout::m2::SkinSection::sortRadius)
    ;

    py::class_<whiteout::m2::Batch>(m, "Batch")
        .def(py::init<>())
        .def_readwrite("flags", &whiteout::m2::Batch::flags)
        .def_readwrite("priority_plane", &whiteout::m2::Batch::priorityPlane)
        .def_readwrite("shader_id", &whiteout::m2::Batch::shaderId)
        .def_readwrite("skin_section_index", &whiteout::m2::Batch::skinSectionIndex)
        .def_readwrite("geoset_index", &whiteout::m2::Batch::geosetIndex)
        .def_readwrite("color_index", &whiteout::m2::Batch::colorIndex)
        .def_readwrite("material_index", &whiteout::m2::Batch::materialIndex)
        .def_readwrite("material_layer", &whiteout::m2::Batch::materialLayer)
        .def_readwrite("texture_count", &whiteout::m2::Batch::textureCount)
        .def_readwrite("texture_combo_index", &whiteout::m2::Batch::textureComboIndex)
        .def_readwrite("texture_coord_combo_index", &whiteout::m2::Batch::textureCoordComboIndex)
        .def_readwrite("texture_weight_combo_index", &whiteout::m2::Batch::textureWeightComboIndex)
        .def_readwrite("texture_transform_combo_index", &whiteout::m2::Batch::textureTransformComboIndex)
    ;

    py::class_<whiteout::m2::ShadowBatch>(m, "ShadowBatch")
        .def(py::init<>())
        .def_readwrite("flags", &whiteout::m2::ShadowBatch::flags)
        .def_readwrite("flags2", &whiteout::m2::ShadowBatch::flags2)
        .def_readwrite("unknown0", &whiteout::m2::ShadowBatch::unknown0)
        .def_readwrite("submesh_id", &whiteout::m2::ShadowBatch::submeshId)
        .def_readwrite("texture_id", &whiteout::m2::ShadowBatch::textureId)
        .def_readwrite("color_id", &whiteout::m2::ShadowBatch::colorId)
        .def_readwrite("transparency_id", &whiteout::m2::ShadowBatch::transparencyId)
    ;

    py::class_<whiteout::m2::SkinProfile>(m, "SkinProfile")
        .def(py::init<>())
        .def_readwrite("vertices", &whiteout::m2::SkinProfile::vertices)
        .def_readwrite("indices", &whiteout::m2::SkinProfile::indices)
        .def_readwrite("submeshes", &whiteout::m2::SkinProfile::submeshes)
        .def_readwrite("batches", &whiteout::m2::SkinProfile::batches)
        .def_readwrite("lod_vertex_base", &whiteout::m2::SkinProfile::lodVertexBase)
        .def_readwrite("shadow_batches", &whiteout::m2::SkinProfile::shadowBatches)
    ;

    py::class_<whiteout::m2::GlobalFlags>(m, "GlobalFlags")
        .def(py::init<>())
        .def_readwrite("value", &whiteout::m2::GlobalFlags::value)
    ;

    py::class_<whiteout::m2::GlobalSequence>(m, "GlobalSequence")
        .def(py::init<>())
        .def_readwrite("timestamp", &whiteout::m2::GlobalSequence::timestamp)
    ;

    py::class_<whiteout::m2::Sequence>(m, "Sequence")
        .def(py::init<>())
        .def_readwrite("id", &whiteout::m2::Sequence::id)
        .def_readwrite("variation_index", &whiteout::m2::Sequence::variationIndex)
        .def_readwrite("duration", &whiteout::m2::Sequence::duration)
        .def_readwrite("movespeed", &whiteout::m2::Sequence::movespeed)
        .def_readwrite("flags", &whiteout::m2::Sequence::flags)
        .def_readwrite("frequency", &whiteout::m2::Sequence::frequency)
        .def_readwrite("padding", &whiteout::m2::Sequence::padding)
        .def_readwrite("replay_min", &whiteout::m2::Sequence::replayMin)
        .def_readwrite("replay_max", &whiteout::m2::Sequence::replayMax)
        .def_readwrite("blend_time_in", &whiteout::m2::Sequence::blendTimeIn)
        .def_readwrite("blend_time_out", &whiteout::m2::Sequence::blendTimeOut)
        .def_readwrite("bounding", &whiteout::m2::Sequence::bounding)
        .def_readwrite("variation_next", &whiteout::m2::Sequence::variationNext)
        .def_readwrite("alias_next", &whiteout::m2::Sequence::aliasNext)
    ;

    py::class_<whiteout::m2::Vertex>(m, "Vertex")
        .def(py::init<>())
        .def_readwrite("position", &whiteout::m2::Vertex::position)
        .def_readwrite("normal", &whiteout::m2::Vertex::normal)
        .def("get_bone_weights",
            [](const whiteout::m2::Vertex& self) {
                return std::vector<whiteout::u8>(self.boneWeights.begin(), self.boneWeights.end());
            })
        .def("set_bone_weights",
            [](whiteout::m2::Vertex& self, const std::vector<whiteout::u8>& v) {
                if (v.size() != self.boneWeights.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.boneWeights.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.boneWeights[i] = v[i];
            })
        .def("get_bone_indices",
            [](const whiteout::m2::Vertex& self) {
                return std::vector<whiteout::u8>(self.boneIndices.begin(), self.boneIndices.end());
            })
        .def("set_bone_indices",
            [](whiteout::m2::Vertex& self, const std::vector<whiteout::u8>& v) {
                if (v.size() != self.boneIndices.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.boneIndices.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.boneIndices[i] = v[i];
            })
        .def("get_tex_coords",
            [](const whiteout::m2::Vertex& self) {
                return std::vector<whiteout::Vector2f>(self.texCoords.begin(), self.texCoords.end());
            })
        .def("set_tex_coords",
            [](whiteout::m2::Vertex& self, const std::vector<whiteout::Vector2f>& v) {
                if (v.size() != self.texCoords.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.texCoords.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.texCoords[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::Bone>(m, "Bone")
        .def(py::init<>())
        .def_readwrite("key_bone_id", &whiteout::m2::Bone::keyBoneId)
        .def_readwrite("flags", &whiteout::m2::Bone::flags)
        .def_readwrite("parent_bone_id", &whiteout::m2::Bone::parentBoneId)
        .def_readwrite("submesh_id", &whiteout::m2::Bone::submeshId)
        .def_readwrite("bone_name_crc", &whiteout::m2::Bone::boneNameCRC)
        .def_readwrite("translation", &whiteout::m2::Bone::translation)
        .def_readwrite("rotation", &whiteout::m2::Bone::rotation)
        .def_readwrite("scale", &whiteout::m2::Bone::scale)
        .def_readwrite("pivot", &whiteout::m2::Bone::pivot)
    ;

    py::class_<whiteout::m2::Texture>(m, "Texture")
        .def(py::init<>())
        .def_readwrite("type", &whiteout::m2::Texture::type)
        .def_readwrite("flags", &whiteout::m2::Texture::flags)
        .def_readwrite("filename", &whiteout::m2::Texture::filename)
    ;

    py::class_<whiteout::m2::Material>(m, "Material")
        .def(py::init<>())
        .def_readwrite("flags", &whiteout::m2::Material::flags)
        .def_readwrite("blending_mode", &whiteout::m2::Material::blendingMode)
    ;

    py::class_<whiteout::m2::TextureWeight>(m, "TextureWeight")
        .def(py::init<>())
        .def_readwrite("weight", &whiteout::m2::TextureWeight::weight)
    ;

    py::class_<whiteout::m2::TextureTransform>(m, "TextureTransform")
        .def(py::init<>())
        .def_readwrite("translation", &whiteout::m2::TextureTransform::translation)
        .def_readwrite("rotation", &whiteout::m2::TextureTransform::rotation)
        .def_readwrite("scaling", &whiteout::m2::TextureTransform::scaling)
    ;

    py::class_<whiteout::m2::ColorAnimation>(m, "ColorAnimation")
        .def(py::init<>())
        .def_readwrite("color", &whiteout::m2::ColorAnimation::color)
        .def_readwrite("alpha", &whiteout::m2::ColorAnimation::alpha)
    ;

    py::class_<whiteout::m2::Light>(m, "Light")
        .def(py::init<>())
        .def_readwrite("type", &whiteout::m2::Light::type)
        .def_readwrite("bone_id", &whiteout::m2::Light::boneId)
        .def_readwrite("position", &whiteout::m2::Light::position)
        .def_readwrite("ambient_color", &whiteout::m2::Light::ambientColor)
        .def_readwrite("ambient_intensity", &whiteout::m2::Light::ambientIntensity)
        .def_readwrite("diffuse_color", &whiteout::m2::Light::diffuseColor)
        .def_readwrite("diffuse_intensity", &whiteout::m2::Light::diffuseIntensity)
        .def_readwrite("attenuation_start", &whiteout::m2::Light::attenuationStart)
        .def_readwrite("attenuation_end", &whiteout::m2::Light::attenuationEnd)
        .def_readwrite("visibility", &whiteout::m2::Light::visibility)
    ;

    py::class_<whiteout::m2::CameraSpline>(m, "CameraSpline")
        .def(py::init<>())
        .def_readwrite("value", &whiteout::m2::CameraSpline::value)
        .def_readwrite("in_tangent", &whiteout::m2::CameraSpline::inTangent)
        .def_readwrite("out_tangent", &whiteout::m2::CameraSpline::outTangent)
    ;

    py::class_<whiteout::m2::Camera>(m, "Camera")
        .def(py::init<>())
        .def_readwrite("type", &whiteout::m2::Camera::type)
        .def_readwrite("field_of_view", &whiteout::m2::Camera::fieldOfView)
        .def_readwrite("far_clip", &whiteout::m2::Camera::farClip)
        .def_readwrite("near_clip", &whiteout::m2::Camera::nearClip)
        .def_readwrite("positions", &whiteout::m2::Camera::positions)
        .def_readwrite("position_base", &whiteout::m2::Camera::positionBase)
        .def_readwrite("target_positions", &whiteout::m2::Camera::targetPositions)
        .def_readwrite("target_position_base", &whiteout::m2::Camera::targetPositionBase)
        .def_readwrite("roll", &whiteout::m2::Camera::roll)
        .def_readwrite("field_of_view_track", &whiteout::m2::Camera::fieldOfViewTrack)
    ;

    py::class_<whiteout::m2::Attachment>(m, "Attachment")
        .def(py::init<>())
        .def_readwrite("id", &whiteout::m2::Attachment::id)
        .def_readwrite("bone_id", &whiteout::m2::Attachment::boneId)
        .def_readwrite("unknown", &whiteout::m2::Attachment::unknown)
        .def_readwrite("position", &whiteout::m2::Attachment::position)
        .def_readwrite("animate", &whiteout::m2::Attachment::animate)
    ;

    py::class_<whiteout::m2::RibbonEmitter>(m, "RibbonEmitter")
        .def(py::init<>())
        .def_readwrite("ribbon_id", &whiteout::m2::RibbonEmitter::ribbonId)
        .def_readwrite("bone_id", &whiteout::m2::RibbonEmitter::boneId)
        .def_readwrite("position", &whiteout::m2::RibbonEmitter::position)
        .def_readwrite("texture_indices", &whiteout::m2::RibbonEmitter::textureIndices)
        .def_readwrite("material_indices", &whiteout::m2::RibbonEmitter::materialIndices)
        .def_readwrite("color_track", &whiteout::m2::RibbonEmitter::colorTrack)
        .def_readwrite("alpha_track", &whiteout::m2::RibbonEmitter::alphaTrack)
        .def_readwrite("height_above", &whiteout::m2::RibbonEmitter::heightAbove)
        .def_readwrite("height_below", &whiteout::m2::RibbonEmitter::heightBelow)
        .def_readwrite("edges_per_second", &whiteout::m2::RibbonEmitter::edgesPerSecond)
        .def_readwrite("edge_lifetime", &whiteout::m2::RibbonEmitter::edgeLifetime)
        .def_readwrite("gravity", &whiteout::m2::RibbonEmitter::gravity)
        .def_readwrite("texture_rows", &whiteout::m2::RibbonEmitter::textureRows)
        .def_readwrite("texture_cols", &whiteout::m2::RibbonEmitter::textureCols)
        .def_readwrite("tex_slot", &whiteout::m2::RibbonEmitter::texSlot)
        .def_readwrite("visibility", &whiteout::m2::RibbonEmitter::visibility)
        .def_readwrite("priority_plane", &whiteout::m2::RibbonEmitter::priorityPlane)
        .def_readwrite("ribbon_color_index", &whiteout::m2::RibbonEmitter::ribbonColorIndex)
        .def_readwrite("texture_transform_index", &whiteout::m2::RibbonEmitter::textureTransformIndex)
    ;

    py::class_<whiteout::m2::M2Box>(m, "Box")
        .def(py::init<>())
        .def_readwrite("minimum", &whiteout::m2::M2Box::minimum)
        .def_readwrite("maximum", &whiteout::m2::M2Box::maximum)
    ;

    py::class_<whiteout::m2::ParticleEmitter>(m, "ParticleEmitter")
        .def(py::init<>())
        .def_readwrite("particle_id", &whiteout::m2::ParticleEmitter::particleId)
        .def_readwrite("flags", &whiteout::m2::ParticleEmitter::flags)
        .def_readwrite("position", &whiteout::m2::ParticleEmitter::position)
        .def_readwrite("bone_id", &whiteout::m2::ParticleEmitter::boneId)
        .def_readwrite("particle_model_filename", &whiteout::m2::ParticleEmitter::particleModelFilename)
        .def_readwrite("child_emitters_model_filename", &whiteout::m2::ParticleEmitter::childEmittersModelFilename)
        .def_readwrite("blending_type", &whiteout::m2::ParticleEmitter::blendingType)
        .def_readwrite("emitter_type", &whiteout::m2::ParticleEmitter::emitterType)
        .def_readwrite("particle_color_index", &whiteout::m2::ParticleEmitter::particleColorIndex)
        .def_readwrite("particle_type", &whiteout::m2::ParticleEmitter::particleType)
        .def_readwrite("head_or_tail", &whiteout::m2::ParticleEmitter::headOrTail)
        .def_readwrite("texture_tilerotation", &whiteout::m2::ParticleEmitter::textureTilerotation)
        .def_readwrite("rows", &whiteout::m2::ParticleEmitter::rows)
        .def_readwrite("columns", &whiteout::m2::ParticleEmitter::columns)
        .def_readwrite("emission_speed", &whiteout::m2::ParticleEmitter::emissionSpeed)
        .def_readwrite("speed_variation", &whiteout::m2::ParticleEmitter::speedVariation)
        .def_readwrite("vertical_range", &whiteout::m2::ParticleEmitter::verticalRange)
        .def_readwrite("horizontal_range", &whiteout::m2::ParticleEmitter::horizontalRange)
        .def_readwrite("gravity", &whiteout::m2::ParticleEmitter::gravity)
        .def_readwrite("lifespan", &whiteout::m2::ParticleEmitter::lifespan)
        .def_readwrite("lifespan_variation", &whiteout::m2::ParticleEmitter::lifespanVariation)
        .def_readwrite("emission_rate", &whiteout::m2::ParticleEmitter::emissionRate)
        .def_readwrite("emission_rate_variation", &whiteout::m2::ParticleEmitter::emissionRateVariation)
        .def_readwrite("emission_area_width", &whiteout::m2::ParticleEmitter::emissionAreaWidth)
        .def_readwrite("emission_area_length", &whiteout::m2::ParticleEmitter::emissionAreaLength)
        .def_readwrite("z_source", &whiteout::m2::ParticleEmitter::zSource)
        .def_readwrite("color_track", &whiteout::m2::ParticleEmitter::colorTrack)
        .def_readwrite("scale_track", &whiteout::m2::ParticleEmitter::scaleTrack)
        .def_readwrite("scale_vary", &whiteout::m2::ParticleEmitter::scaleVary)
        .def_readwrite("tail_length", &whiteout::m2::ParticleEmitter::tailLength)
        .def_readwrite("twinkle_speed", &whiteout::m2::ParticleEmitter::twinkleSpeed)
        .def_readwrite("twinkle_percent", &whiteout::m2::ParticleEmitter::twinklePercent)
        .def_readwrite("twinkle_scale", &whiteout::m2::ParticleEmitter::twinkleScale)
        .def_readwrite("inherit_velocity_scale", &whiteout::m2::ParticleEmitter::inheritVelocityScale)
        .def_readwrite("drag", &whiteout::m2::ParticleEmitter::drag)
        .def_readwrite("base_spin", &whiteout::m2::ParticleEmitter::baseSpin)
        .def_readwrite("base_spin_variation", &whiteout::m2::ParticleEmitter::baseSpinVariation)
        .def_readwrite("spin_speed", &whiteout::m2::ParticleEmitter::spinSpeed)
        .def_readwrite("spin_speed_variation", &whiteout::m2::ParticleEmitter::spinSpeedVariation)
        .def_readwrite("tumble", &whiteout::m2::ParticleEmitter::tumble)
        .def_readwrite("wind_vector", &whiteout::m2::ParticleEmitter::windVector)
        .def_readwrite("wind_time", &whiteout::m2::ParticleEmitter::windTime)
        .def_readwrite("follow_speed1", &whiteout::m2::ParticleEmitter::followSpeed1)
        .def_readwrite("follow_scale1", &whiteout::m2::ParticleEmitter::followScale1)
        .def_readwrite("follow_speed2", &whiteout::m2::ParticleEmitter::followSpeed2)
        .def_readwrite("follow_scale2", &whiteout::m2::ParticleEmitter::followScale2)
        .def_readwrite("spline_points", &whiteout::m2::ParticleEmitter::splinePoints)
        .def_readwrite("enabled_in", &whiteout::m2::ParticleEmitter::enabledIn)
        .def_readwrite("extension", &whiteout::m2::ParticleEmitter::extension)
        .def("get_multi_tex_scale",
            [](const whiteout::m2::ParticleEmitter& self) {
                return std::vector<whiteout::fixed_point<signed char, 5>>(self.multiTexScale.begin(), self.multiTexScale.end());
            })
        .def("set_multi_tex_scale",
            [](whiteout::m2::ParticleEmitter& self, const std::vector<whiteout::fixed_point<signed char, 5>>& v) {
                if (v.size() != self.multiTexScale.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.multiTexScale.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.multiTexScale[i] = v[i];
            })
        .def("get_multi_tex_scroll_mid",
            [](const whiteout::m2::ParticleEmitter& self) {
                return std::vector<std::array<whiteout::fixed_point<unsigned short, 9>, 2>>(self.multiTexScrollMid.begin(), self.multiTexScrollMid.end());
            })
        .def("set_multi_tex_scroll_mid",
            [](whiteout::m2::ParticleEmitter& self, const std::vector<std::array<whiteout::fixed_point<unsigned short, 9>, 2>>& v) {
                if (v.size() != self.multiTexScrollMid.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.multiTexScrollMid.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.multiTexScrollMid[i] = v[i];
            })
        .def("get_multi_tex_scroll_range",
            [](const whiteout::m2::ParticleEmitter& self) {
                return std::vector<std::array<whiteout::fixed_point<unsigned short, 9>, 2>>(self.multiTexScrollRange.begin(), self.multiTexScrollRange.end());
            })
        .def("set_multi_tex_scroll_range",
            [](whiteout::m2::ParticleEmitter& self, const std::vector<std::array<whiteout::fixed_point<unsigned short, 9>, 2>>& v) {
                if (v.size() != self.multiTexScrollRange.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.multiTexScrollRange.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.multiTexScrollRange[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::Event>(m, "Event")
        .def(py::init<>())
        .def_readwrite("identifier", &whiteout::m2::Event::identifier)
        .def_readwrite("data", &whiteout::m2::Event::data)
        .def_readwrite("bone_id", &whiteout::m2::Event::boneId)
        .def_readwrite("position", &whiteout::m2::Event::position)
        .def_readwrite("enabled", &whiteout::m2::Event::enabled)
    ;

    py::class_<whiteout::m2::PhysicsBody>(m, "PhysicsBody", R"doc(One rigid body, bound to a single model bone — BODY/BDY2/BDY3/BDY4.

The four on-disk layouts are the same fields accreting over time, so they share one struct; PhysicsData::version decides which of them is written back, and fields the older layouts lack keep their defaults.)doc")
        .def(py::init<>())
        .def_readwrite("type", &whiteout::m2::PhysicsBody::type)
        .def_readwrite("bone_index", &whiteout::m2::PhysicsBody::boneIndex)
        .def_readwrite("position", &whiteout::m2::PhysicsBody::position, R"doc(Offset from the bone's animated position, not an absolute position: the client spawns the body at `bonePosition + position`.)doc")
        .def_readwrite("shape_index", &whiteout::m2::PhysicsBody::shapeIndex, R"doc(First entry in PhysicsData::shapes belonging to this body. 32 bits wide in BODY/BDY2, 16 from BDY3 on — writing a larger index back into one of those truncates it.)doc")
        .def_readwrite("shape_count", &whiteout::m2::PhysicsBody::shapeCount)
        .def_readwrite("gravity_scale", &whiteout::m2::PhysicsBody::gravityScale, R"doc(BDY3+. 1.0 on all but 45 of 1213 kinematic bodies but tuned freely on dynamic ones, negatives included — the shape of `dmBodyDef::m_gravityScale`.)doc")
        .def_readwrite("inertia_scale", &whiteout::m2::PhysicsBody::inertiaScale, R"doc(BDY2+. 1.0 in 3457 of 3526 bodies, otherwise 1.1-10 — `dmBodyDef::m_inertiaScale`.)doc")
        .def_readwrite("linear_damping", &whiteout::m2::PhysicsBody::linearDamping, R"doc(BDY3+. Zero on 1196 of 1213 kinematic bodies and 0-10 on dynamic ones — `dmBodyDef::m_linearDamping`.)doc")
        .def_readwrite("angular_damping", &whiteout::m2::PhysicsBody::angularDamping, R"doc(BDY3+. Same kinematic/dynamic split as @ref linearDamping — `dmBodyDef::m_angularDamping`.)doc")
        .def_readwrite("unknown28", &whiteout::m2::PhysicsBody::unknown28, R"doc(BDY3+. Unidentified. Unlike the four above it is set on kinematic and dynamic bodies alike, so it is not a rigid-body integration parameter; values cluster on 0.5, 0.01, 0.9 and 0.1.)doc")
        .def_readwrite("unknown2c", &whiteout::m2::PhysicsBody::unknown2c, R"doc(BDY4+. Unidentified; 0 in half the corpus, otherwise small values or 0x8000 alone, which reads like a bit field.)doc")
        .def_readwrite("padding2e", &whiteout::m2::PhysicsBody::padding2e, R"doc(BDY4+. Zero in every corpus body.)doc")
    ;

    py::class_<whiteout::m2::PhysicsShape>(m, "PhysicsShape", R"doc(One collision shape reference — SHAP/SHP2. Points at an entry of the box/capsule/sphere/polytope array named by @ref shapeType.)doc")
        .def(py::init<>())
        .def_readwrite("shape_type", &whiteout::m2::PhysicsShape::shapeType)
        .def_readwrite("shape_index", &whiteout::m2::PhysicsShape::shapeIndex)
        .def_readwrite("padding04", &whiteout::m2::PhysicsShape::padding04, R"doc(Zero in every corpus shape.)doc")
        .def_readwrite("friction", &whiteout::m2::PhysicsShape::friction)
        .def_readwrite("restitution", &whiteout::m2::PhysicsShape::restitution)
        .def_readwrite("density", &whiteout::m2::PhysicsShape::density)
        .def_readwrite("unknown14", &whiteout::m2::PhysicsShape::unknown14, R"doc(SHP2+. Unidentified, but a float: only 0, 0.01, 0.8 and 1.0 occur. The one `dmFixtureDef` float the rest of this struct does not account for is `m_rollingResistance`.)doc")
        .def_readwrite("scale", &whiteout::m2::PhysicsShape::scale, R"doc(SHP2+. 1.0 in 3229 of 3230 shapes, matching the `m_scaleOrRadius` the client hands every fixture.)doc")
        .def_readwrite("unknown1c", &whiteout::m2::PhysicsShape::unknown1c, R"doc(SHP2+. Zero in every corpus shape.)doc")
        .def_readwrite("padding1e", &whiteout::m2::PhysicsShape::padding1e, R"doc(SHP2+. Uninitialised on disk; kept so writes match.)doc")
    ;

    py::class_<whiteout::m2::BoxShape>(m, "BoxShape", R"doc(BOXS — an oriented box. The client turns it straight into a polytope via `CPhysicsBoxShapeDef::SetPolytopeData(frame, halfExtents)`.)doc")
        .def(py::init<>())
        .def_readwrite("frame", &whiteout::m2::BoxShape::frame)
        .def_readwrite("half_extents", &whiteout::m2::BoxShape::halfExtents)
    ;

    py::class_<whiteout::m2::CapsuleShape>(m, "CapsuleShape", R"doc(CAPS — a capsule between two local points.)doc")
        .def(py::init<>())
        .def_readwrite("local_position1", &whiteout::m2::CapsuleShape::localPosition1)
        .def_readwrite("local_position2", &whiteout::m2::CapsuleShape::localPosition2)
        .def_readwrite("radius", &whiteout::m2::CapsuleShape::radius)
    ;

    py::class_<whiteout::m2::SphereShape>(m, "SphereShape", R"doc(SPHS — a sphere at a local point.)doc")
        .def(py::init<>())
        .def_readwrite("local_position", &whiteout::m2::SphereShape::localPosition)
        .def_readwrite("radius", &whiteout::m2::SphereShape::radius)
    ;

    py::class_<whiteout::m2::PolytopeHalfEdge>(m, "PolytopeHalfEdge", R"doc(One half-edge of a polytope — Domino's `dmSubEdge`, four bytes.

Half-edges are stored in twin pairs at adjacent indices, and the ones bounding a face form a cycle through @ref nextEdge.)doc")
        .def(py::init<>())
        .def_readwrite("twin_offset", &whiteout::m2::PolytopeHalfEdge::twinOffset, R"doc(Signed step to the paired half-edge: the twin of edge `i` is `i + twinOffset`. Only +1 and -1 occur, in equal numbers.)doc")
        .def_readwrite("origin_vertex", &whiteout::m2::PolytopeHalfEdge::originVertex, R"doc(Where this half-edge starts, indexing PolytopeShape::vertices.)doc")
        .def_readwrite("face_index", &whiteout::m2::PolytopeHalfEdge::faceIndex, R"doc(The face this half-edge bounds, indexing PolytopeShape::facePlanes.)doc")
        .def_readwrite("next_edge", &whiteout::m2::PolytopeHalfEdge::nextEdge, R"doc(Next half-edge around @ref faceIndex.)doc")
    ;

    py::class_<whiteout::m2::PolytopeShape>(m, "PolytopeShape", R"doc(PLYT — a convex hull, version 3+. Domino's `dmPolytope`.

The chunk stores fixed-size headers and variable-size payloads in two blocks; both halves are folded into this one struct, and the header's counts are recomputed from the vectors on write. The header's four pointer fields are filled in by the client at load time and are zero in every file, so they are not kept.)doc")
        .def(py::init<>())
        .def_readwrite("vertices", &whiteout::m2::PolytopeShape::vertices, R"doc(Hull corners.)doc")
        .def_readwrite("face_planes", &whiteout::m2::PolytopeShape::facePlanes, R"doc(Outward plane of each face, `xyz` normal and `w` offset.)doc")
        .def_readwrite("face_first_edges", &whiteout::m2::PolytopeShape::faceFirstEdges, R"doc(One entry per face: any half-edge bounding it, as the entry point for walking the face through PolytopeHalfEdge::nextEdge.)doc")
        .def_readwrite("edges", &whiteout::m2::PolytopeShape::edges)
        .def_readwrite("centroid", &whiteout::m2::PolytopeShape::centroid, R"doc(Volume-weighted, not the vertex average.)doc")
        .def_readwrite("volume", &whiteout::m2::PolytopeShape::volume, R"doc(Hull volume.)doc")
        .def_readwrite("surface_area", &whiteout::m2::PolytopeShape::surfaceArea, R"doc(Hull surface area.)doc")
        .def_readwrite("padding04", &whiteout::m2::PolytopeShape::padding04, R"doc(The four-byte gaps each count leaves in front of its 64-bit pointer, and the one that trails the header. Uninitialised in the files — some carry fragments of unrelated strings — so they are kept verbatim for writing.)doc")
        .def_readwrite("padding14", &whiteout::m2::PolytopeShape::padding14)
        .def_readwrite("padding2c", &whiteout::m2::PolytopeShape::padding2c)
        .def_readwrite("padding4c", &whiteout::m2::PolytopeShape::padding4c)
    ;

    py::class_<whiteout::m2::PhysicsJoint>(m, "PhysicsJoint", R"doc(JOIN — connects two bodies with the joint named by @ref jointType.)doc")
        .def(py::init<>())
        .def_readwrite("body_a_index", &whiteout::m2::PhysicsJoint::bodyAIndex)
        .def_readwrite("body_b_index", &whiteout::m2::PhysicsJoint::bodyBIndex)
        .def_readwrite("padding08", &whiteout::m2::PhysicsJoint::padding08, R"doc(Zero in every corpus joint.)doc")
        .def_readwrite("joint_type", &whiteout::m2::PhysicsJoint::jointType)
        .def_readwrite("joint_id", &whiteout::m2::PhysicsJoint::jointId, R"doc(Entry index within the joint array @ref jointType selects.)doc")
    ;

    py::class_<whiteout::m2::WeldJoint>(m, "WeldJoint", R"doc(WELJ/WLJ2/WLJ3 — a soft rigid connection. Zero frequency means the axis is solved as a hard constraint.)doc")
        .def(py::init<>())
        .def_readwrite("frame_a", &whiteout::m2::WeldJoint::frameA)
        .def_readwrite("frame_b", &whiteout::m2::WeldJoint::frameB)
        .def_readwrite("angular_frequency_hz", &whiteout::m2::WeldJoint::angularFrequencyHz)
        .def_readwrite("angular_damping_ratio", &whiteout::m2::WeldJoint::angularDampingRatio)
        .def_readwrite("linear_frequency_hz", &whiteout::m2::WeldJoint::linearFrequencyHz, R"doc(WLJ2+)doc")
        .def_readwrite("linear_damping_ratio", &whiteout::m2::WeldJoint::linearDampingRatio, R"doc(WLJ2+)doc")
        .def_readwrite("unknown70", &whiteout::m2::WeldJoint::unknown70, R"doc(WLJ3+. Zero in 265 of 274 weld joints.)doc")
    ;

    py::class_<whiteout::m2::SphericalJoint>(m, "SphericalJoint", R"doc(SPHJ — a ball joint between two anchor points.)doc")
        .def(py::init<>())
        .def_readwrite("anchor_a", &whiteout::m2::SphericalJoint::anchorA)
        .def_readwrite("anchor_b", &whiteout::m2::SphericalJoint::anchorB)
        .def_readwrite("friction_torque", &whiteout::m2::SphericalJoint::frictionTorque)
    ;

    py::class_<whiteout::m2::ShoulderJoint>(m, "ShoulderJoint", R"doc(SHOJ/SHJ2 — a twist-and-cone joint, the one that chains cloth.)doc")
        .def(py::init<>())
        .def_readwrite("frame_a", &whiteout::m2::ShoulderJoint::frameA)
        .def_readwrite("frame_b", &whiteout::m2::ShoulderJoint::frameB)
        .def_readwrite("lower_twist_angle", &whiteout::m2::ShoulderJoint::lowerTwistAngle)
        .def_readwrite("upper_twist_angle", &whiteout::m2::ShoulderJoint::upperTwistAngle)
        .def_readwrite("cone_angle", &whiteout::m2::ShoulderJoint::coneAngle, R"doc(Degrees: the corpus holds 20, 35, 45 and 60, while `dmShoulderJoint` clamps its own cone to [10°, 170°] expressed in radians — so the loader converts on the way in.)doc")
        .def_readwrite("max_motor_torque", &whiteout::m2::ShoulderJoint::maxMotorTorque, R"doc(version 2+)doc")
        .def_readwrite("motor_mode", &whiteout::m2::ShoulderJoint::motorMode, R"doc(version 2+)doc")
        .def_readwrite("motor_frequency_hz", &whiteout::m2::ShoulderJoint::motorFrequencyHz, R"doc(SHJ2)doc")
        .def_readwrite("motor_damping_ratio", &whiteout::m2::ShoulderJoint::motorDampingRatio, R"doc(SHJ2)doc")
    ;

    py::class_<whiteout::m2::PrismaticJoint>(m, "PrismaticJoint", R"doc(PRSJ/PRS2 — a sliding joint, version 2+.)doc")
        .def(py::init<>())
        .def_readwrite("frame_a", &whiteout::m2::PrismaticJoint::frameA)
        .def_readwrite("frame_b", &whiteout::m2::PrismaticJoint::frameB)
        .def_readwrite("lower_limit", &whiteout::m2::PrismaticJoint::lowerLimit)
        .def_readwrite("upper_limit", &whiteout::m2::PrismaticJoint::upperLimit)
        .def_readwrite("unknown68", &whiteout::m2::PrismaticJoint::unknown68, R"doc(Unidentified; zero in all twelve corpus prismatic joints. Domino's prismatic def carries an enable-limit flag next to the limit pair.)doc")
        .def_readwrite("max_motor_force", &whiteout::m2::PrismaticJoint::maxMotorForce)
        .def_readwrite("unknown70", &whiteout::m2::PrismaticJoint::unknown70, R"doc(Unidentified; zero in all twelve.)doc")
        .def_readwrite("motor_mode", &whiteout::m2::PrismaticJoint::motorMode)
        .def_readwrite("motor_frequency_hz", &whiteout::m2::PrismaticJoint::motorFrequencyHz, R"doc(PRS2)doc")
        .def_readwrite("motor_damping_ratio", &whiteout::m2::PrismaticJoint::motorDampingRatio, R"doc(PRS2)doc")
    ;

    py::class_<whiteout::m2::RevoluteJoint>(m, "RevoluteJoint", R"doc(REVJ/REV2 — a hinge, version 2+.)doc")
        .def(py::init<>())
        .def_readwrite("frame_a", &whiteout::m2::RevoluteJoint::frameA)
        .def_readwrite("frame_b", &whiteout::m2::RevoluteJoint::frameB)
        .def_readwrite("lower_angle", &whiteout::m2::RevoluteJoint::lowerAngle)
        .def_readwrite("upper_angle", &whiteout::m2::RevoluteJoint::upperAngle)
        .def_readwrite("max_motor_torque", &whiteout::m2::RevoluteJoint::maxMotorTorque)
        .def_readwrite("motor_mode", &whiteout::m2::RevoluteJoint::motorMode, R"doc(1: position mode (frequency > 0), 2: velocity mode.)doc")
        .def_readwrite("motor_frequency_hz", &whiteout::m2::RevoluteJoint::motorFrequencyHz, R"doc(REV2)doc")
        .def_readwrite("motor_damping_ratio", &whiteout::m2::RevoluteJoint::motorDampingRatio, R"doc(REV2)doc")
    ;

    py::class_<whiteout::m2::DistanceJoint>(m, "DistanceJoint", R"doc(DSTJ — holds two anchors a fixed distance apart, version 2+.)doc")
        .def(py::init<>())
        .def_readwrite("local_anchor_a", &whiteout::m2::DistanceJoint::localAnchorA)
        .def_readwrite("local_anchor_b", &whiteout::m2::DistanceJoint::localAnchorB)
        .def_readwrite("distance", &whiteout::m2::DistanceJoint::distance)
    ;

    py::class_<whiteout::m2::PhysicsTuning>(m, "PhysicsTuning", R"doc(PHYV — six floats that overwrite the head of a tuning block the client otherwise fills with constants. Version 1+.)doc")
        .def(py::init<>())
        .def("get_values",
            [](const whiteout::m2::PhysicsTuning& self) {
                return std::vector<whiteout::f32>(self.values.begin(), self.values.end());
            })
        .def("set_values",
            [](whiteout::m2::PhysicsTuning& self, const std::vector<whiteout::f32>& v) {
                if (v.size() != self.values.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.values.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.values[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::PhysicsUnknownChunk>(m, "PhysicsUnknownChunk", R"doc(A `.phys` chunk this library does not know, kept verbatim so a parse/write cycle does not drop it.)doc")
        .def(py::init<>())
        .def_readwrite("data", &whiteout::m2::PhysicsUnknownChunk::data)
        .def("get_tag",
            [](const whiteout::m2::PhysicsUnknownChunk& self) {
                return std::vector<char>(self.tag.begin(), self.tag.end());
            })
        .def("set_tag",
            [](whiteout::m2::PhysicsUnknownChunk& self, const std::vector<char>& v) {
                if (v.size() != self.tag.size())
                    throw std::runtime_error("setter expected exactly "
                        + std::to_string(self.tag.size()) + " elements");
                for (std::size_t i = 0; i < v.size(); ++i) self.tag[i] = v[i];
            })
    ;

    py::class_<whiteout::m2::PhysicsData>(m, "PhysicsData", R"doc(A whole `.phys` file — Blizzard's Domino rigid-body setup for a model, either a `.phys` sibling or an M2's inline PFDC chunk.

Bodies attach to bones and are linked by joints; each body owns a run of @ref shapes, and each shape indexes the array its type names.)doc")
        .def(py::init<>())
        .def_readwrite("version", &whiteout::m2::PhysicsData::version, R"doc(0 (MoP) through 6. Decides which layout each chunk is written in — see the per-field version notes on the structs above.)doc")
        .def_readwrite("phyt", &whiteout::m2::PhysicsData::phyt, R"doc(PHYT, version 1+. A small enum, 0 through 4; meaning unknown.)doc")
        .def_readwrite("bodies", &whiteout::m2::PhysicsData::bodies)
        .def_readwrite("shapes", &whiteout::m2::PhysicsData::shapes)
        .def_readwrite("box_shapes", &whiteout::m2::PhysicsData::boxShapes)
        .def_readwrite("capsule_shapes", &whiteout::m2::PhysicsData::capsuleShapes)
        .def_readwrite("sphere_shapes", &whiteout::m2::PhysicsData::sphereShapes)
        .def_readwrite("polytope_shapes", &whiteout::m2::PhysicsData::polytopeShapes)
        .def_readwrite("joints", &whiteout::m2::PhysicsData::joints)
        .def_readwrite("weld_joints", &whiteout::m2::PhysicsData::weldJoints)
        .def_readwrite("spherical_joints", &whiteout::m2::PhysicsData::sphericalJoints)
        .def_readwrite("shoulder_joints", &whiteout::m2::PhysicsData::shoulderJoints)
        .def_readwrite("prismatic_joints", &whiteout::m2::PhysicsData::prismaticJoints)
        .def_readwrite("revolute_joints", &whiteout::m2::PhysicsData::revoluteJoints)
        .def_readwrite("distance_joints", &whiteout::m2::PhysicsData::distanceJoints)
        .def_readwrite("tuning", &whiteout::m2::PhysicsData::tuning, R"doc(PHYV. A file that has one carries nothing else.)doc")
    ;

    py::class_<whiteout::m2::BoneOverride>(m, "BoneOverride", R"doc(One bone's replacement transform, from a `.bone` file.)doc")
        .def(py::init<>())
        .def_readwrite("bone_index", &whiteout::m2::BoneOverride::boneIndex, R"doc(Indexes Model::bones. Every id in the WoW corpus is below its model's bone count, and the ids within a file are strictly ascending.)doc")
    ;

    py::class_<whiteout::m2::BoneOverrideSet>(m, "BoneOverrideSet", R"doc(A whole `.bone` file: the skeleton edits one customization choice needs.

On disk this is two parallel chunks — `BIDA` holds the bone ids and `BOMT` the matrices — but their lengths match in every corpus file, so they are paired here and split again on write.)doc")
        .def(py::init<>())
        .def_readwrite("version", &whiteout::m2::BoneOverrideSet::version, R"doc(1 in every known file.)doc")
        .def_readwrite("overrides", &whiteout::m2::BoneOverrideSet::overrides, R"doc(Ascending by @ref BoneOverride::boneIndex, which is the order the files store and what lets the client binary-search a bone.)doc")
    ;

    py::class_<whiteout::m2::Model>(m, "Model")
        .def(py::init<>())
        .def_readwrite("model_name", &whiteout::m2::Model::modelName)
        .def_readwrite("global_flags", &whiteout::m2::Model::globalFlags)
        .def_readwrite("global_loops", &whiteout::m2::Model::globalLoops)
        .def_readwrite("sequences", &whiteout::m2::Model::sequences)
        .def_readwrite("sequence_idx_hash_by_id", &whiteout::m2::Model::sequenceIdxHashById)
        .def_readwrite("bones", &whiteout::m2::Model::bones)
        .def_readwrite("key_bone_ids", &whiteout::m2::Model::keyBoneIds)
        .def_readwrite("vertices", &whiteout::m2::Model::vertices)
        .def_readwrite("skin_profiles", &whiteout::m2::Model::skinProfiles)
        .def_readwrite("lod_profiles", &whiteout::m2::Model::lodProfiles)
        .def_readwrite("num_skin_profiles", &whiteout::m2::Model::numSkinProfiles)
        .def_readwrite("colors", &whiteout::m2::Model::colors)
        .def_readwrite("textures", &whiteout::m2::Model::textures)
        .def_readwrite("texture_weights", &whiteout::m2::Model::textureWeights)
        .def_readwrite("texture_transforms", &whiteout::m2::Model::textureTransforms)
        .def_readwrite("texture_indices_by_id", &whiteout::m2::Model::textureIndicesById)
        .def_readwrite("materials", &whiteout::m2::Model::materials)
        .def_readwrite("bone_combos", &whiteout::m2::Model::boneCombos)
        .def_readwrite("texture_combos", &whiteout::m2::Model::textureCombos)
        .def_readwrite("texture_coord_combos", &whiteout::m2::Model::textureCoordCombos)
        .def_readwrite("texture_weight_combos", &whiteout::m2::Model::textureWeightCombos)
        .def_readwrite("texture_transform_combos", &whiteout::m2::Model::textureTransformCombos)
        .def_readwrite("bounding", &whiteout::m2::Model::bounding)
        .def_readwrite("collision", &whiteout::m2::Model::collision)
        .def_readwrite("collision_triangle_indices", &whiteout::m2::Model::collisionTriangleIndices)
        .def_readwrite("collision_vertices", &whiteout::m2::Model::collisionVertices)
        .def_readwrite("collision_face_normals", &whiteout::m2::Model::collisionFaceNormals)
        .def_readwrite("attachments", &whiteout::m2::Model::attachments)
        .def_readwrite("attachment_indices_by_id", &whiteout::m2::Model::attachmentIndicesById)
        .def_readwrite("events", &whiteout::m2::Model::events)
        .def_readwrite("lights", &whiteout::m2::Model::lights)
        .def_readwrite("cameras", &whiteout::m2::Model::cameras)
        .def_readwrite("camera_indices_by_id", &whiteout::m2::Model::cameraIndicesById)
        .def_readwrite("ribbon_emitters", &whiteout::m2::Model::ribbonEmitters)
        .def_readwrite("particle_emitters", &whiteout::m2::Model::particleEmitters)
        .def_readwrite("texture_combiner_combos", &whiteout::m2::Model::textureCombinerCombos)
        .def_readwrite("playable_animation_lookup", &whiteout::m2::Model::playableAnimationLookup, R"doc(One 4-byte record per animation id; vanilla/BC clients use it to pick fallback animations. Preserved verbatim so old files round-trip.)doc")
        .def_readwrite("texture_flipbooks", &whiteout::m2::Model::textureFlipbooks, R"doc("Texture flipbooks" — unused even by old clients, preserved verbatim.)doc")
        .def_readwrite("texture_ids", &whiteout::m2::Model::texture_ids, R"doc(TXID)doc")
        .def_readwrite("lod_profile", &whiteout::m2::Model::lodProfile, R"doc(LDV1)doc")
        .def_readwrite("parent_sequence_replacements", &whiteout::m2::Model::parentSequenceReplacements, R"doc(PABC)doc")
        .def_readwrite("parent_texture_weights", &whiteout::m2::Model::parentTextureWeights, R"doc(PADC)doc")
        .def_readwrite("parent_sequence_bounds", &whiteout::m2::Model::parentSequenceBounds, R"doc(PSBC)doc")
        .def_readwrite("parent_event_data", &whiteout::m2::Model::parentEventData, R"doc(PEDC)doc")
        .def_readwrite("recursive_particle_model_ids", &whiteout::m2::Model::recursiveParticleModelIds, R"doc(RPID)doc")
        .def_readwrite("geometry_particle_model_ids", &whiteout::m2::Model::geometryParticleModelIds, R"doc(GPID)doc")
        .def_readwrite("water_data", &whiteout::m2::Model::waterData, R"doc(WFV3)doc")
        .def_readwrite("particle_geosets", &whiteout::m2::Model::particleGeosets, R"doc(PGD1)doc")
        .def_readwrite("physics", &whiteout::m2::Model::physics, R"doc(PFDC, or a `.phys` sibling)doc")
        .def_readwrite("physics_file_id", &whiteout::m2::Model::physicsFileId)
        .def_readwrite("bone_overrides", &whiteout::m2::Model::boneOverrides, R"doc(One entry per customization choice, in BFID order — see bone_file.h.)doc")
        .def_readwrite("bone_file_ids", &whiteout::m2::Model::boneFileIds, R"doc(BFID, kept so a model that named its `.bone` files by id keeps doing so. Parallel to @ref boneOverrides when both are present.)doc")
        .def_readwrite("edge_fade_entries", &whiteout::m2::Model::edgeFadeEntries, R"doc(EDGF)doc")
        .def_readwrite("nerf_entries", &whiteout::m2::Model::nerfEntries, R"doc(NERF)doc")
        .def_readwrite("detailed_light_entries", &whiteout::m2::Model::detailedLightEntries, R"doc(DETL)doc")
        .def_readwrite("debug_occlusion_entries", &whiteout::m2::Model::debugOcclusionEntries, R"doc(DBOC)doc")
        .def_readwrite("anim_frame_data", &whiteout::m2::Model::animFrameData, R"doc(AFRA)doc")
        .def_readwrite("physics_collision", &whiteout::m2::Model::physicsCollision, R"doc(PCOL)doc")
        .def_readwrite("dpiv_data", &whiteout::m2::Model::dpivData, R"doc(DPIV (32 B per record))doc")
        .def_readwrite("textured_light_entries", &whiteout::m2::Model::texturedLightEntries, R"doc(TEXL)doc")
    ;

    py::class_<whiteout::m2::Parser>(m, "Parser")
        .def(py::init<>())
        .def("parse", py::overload_cast<whiteout::interfaces::VirtualPathFileSystem&, const std::string&>(&whiteout::m2::Parser::parse), py::arg("fs"), py::arg("filePath"))
        .def("parse",
            [](whiteout::m2::Parser& self, whiteout::interfaces::CascFileSystem& cascFs, py::bytes __py_bytes_1) {
                std::string __s_1 = __py_bytes_1;
                std::span<const whiteout::u8> buffer(reinterpret_cast<const whiteout::u8*>(__s_1.data()), __s_1.size());
                return self.parse(cascFs, buffer);
            }, py::arg("cascFs"), py::arg("buffer"))
        .def("set_lazy_animations", &whiteout::m2::Parser::setLazyAnimations, py::arg("enable"), R"doc(Leave the keys of sequences stored in `.anim` siblings unread until m2::loadSequence() asks for them. Off by default.

This is what the client does — nothing reads a `.anim` until something plays that sequence — and on a character model with a hundred of them it is the difference between a load that reads one file and one that reads a hundred. See sequence_loader.h.

The @p fs passed to parse() has to outlive the returned Model, because the deferred reads go back through it.)doc")
        .def("has_issues", &whiteout::m2::Parser::hasIssues)
        .def("get_issues", &whiteout::m2::Parser::getIssues)
    ;

    py::class_<whiteout::m2::WriteOptions>(m, "WriteOptions")
        .def(py::init<>())
        .def_readwrite("m2_version", &whiteout::m2::WriteOptions::m2Version)
        .def_readwrite("emit_skeleton", &whiteout::m2::WriteOptions::emitSkeleton)
        .def_readwrite("base_stem", &whiteout::m2::WriteOptions::baseStem)
    ;

    py::class_<whiteout::m2::M2SerializeResult>(m, "SerializeResult")
        .def(py::init<>())
        .def_readwrite("m2_data", &whiteout::m2::M2SerializeResult::m2Data)
        .def_readwrite("skeleton_data", &whiteout::m2::M2SerializeResult::skeletonData)
        .def_readwrite("physics_data", &whiteout::m2::M2SerializeResult::physicsData)
    ;

    py::class_<whiteout::m2::Writer>(m, "Writer")
        .def(py::init<>())
        .def(py::init<whiteout::m2::WriteOptions>(), py::arg("options"))
        .def("write", py::overload_cast<whiteout::interfaces::VirtualPathFileSystem&, const std::string&, const whiteout::m2::Model&>(&whiteout::m2::Writer::write), py::arg("fs"), py::arg("filePath"), py::arg("model"))
        .def("write", py::overload_cast<whiteout::interfaces::CascFileSystem&, const whiteout::m2::Model&>(&whiteout::m2::Writer::write), py::arg("cascFs"), py::arg("model"))
        .def("write", py::overload_cast<const whiteout::m2::Model&>(&whiteout::m2::Writer::write), py::arg("model"))
        .def("has_issues", &whiteout::m2::Writer::hasIssues)
        .def("get_issues", &whiteout::m2::Writer::getIssues)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::Vector3f>>(m, "AnimationTrackVector3f", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::Vector3f>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::Vector3f>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::Vector3f>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::Vector3f>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>>(m, "AnimationTrackM2CompatQuaternion", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::i16>>(m, "AnimationTrackI16", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::i16>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::i16>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::i16>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::i16>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::Quaternion>>(m, "AnimationTrackQuaternion", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::Quaternion>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::Quaternion>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::Quaternion>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::Quaternion>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::f32>>(m, "AnimationTrackF32", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::f32>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::f32>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::f32>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::f32>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::u8>>(m, "AnimationTrackU8", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::u8>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::u8>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::u8>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::u8>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>>(m, "AnimationTrackM2CameraSpline", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>::values)
    ;

    py::class_<whiteout::m2::AnimationTrack<whiteout::u16>>(m, "AnimationTrackU16", R"doc(instantiate=Vector3f;CompatQuaternion;Quaternion;i16;u8;u16;f32;CameraSpline)doc")
        .def(py::init<>())
        .def_readwrite("interpolation_type", &whiteout::m2::AnimationTrack<whiteout::u16>::interpolationType)
        .def_readwrite("global_sequence_id", &whiteout::m2::AnimationTrack<whiteout::u16>::globalSequenceId)
        .def_readwrite("timestamps", &whiteout::m2::AnimationTrack<whiteout::u16>::timestamps)
        .def_readwrite("values", &whiteout::m2::AnimationTrack<whiteout::u16>::values)
    ;

    py::class_<whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>>(m, "ParticleAnimationTrackVector3f")
        .def(py::init<>())
        .def_readwrite("values", &whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>::values)
    ;

    py::class_<whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>>(m, "ParticleAnimationTrackVector2f")
        .def(py::init<>())
        .def_readwrite("values", &whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>::values)
    ;

    py::bind_vector<std::vector<whiteout::i16>>(m, "VectorI16", py::buffer_protocol());
    py::bind_vector<std::vector<std::vector<whiteout::u32>>>(m, "VectorVectorU32");
    py::bind_vector<std::vector<std::vector<whiteout::Quaternion>>>(m, "VectorVectorQuaternion");
    py::bind_vector<std::vector<std::vector<whiteout::Vector3f>>>(m, "VectorVectorVector3f");
    py::bind_vector<std::vector<std::vector<whiteout::f32>>>(m, "VectorVectorF32");
    py::bind_vector<std::vector<std::vector<whiteout::i16>>>(m, "VectorVectorI16");
    py::bind_vector<std::vector<std::vector<whiteout::m2::CameraSpline>>>(m, "VectorVectorM2CameraSpline");
    py::bind_vector<std::vector<std::vector<whiteout::m2::CompatQuaternion>>>(m, "VectorVectorM2CompatQuaternion");
    py::bind_vector<std::vector<std::vector<whiteout::u16>>>(m, "VectorVectorU16");
    py::bind_vector<std::vector<std::vector<whiteout::u8>>>(m, "VectorVectorU8");
    py::bind_vector<std::vector<whiteout::m2::AnimationTrackBase>>(m, "VectorM2AnimationTrackBase");
    py::bind_vector<std::vector<whiteout::m2::Attachment>>(m, "VectorM2Attachment");
    py::bind_vector<std::vector<whiteout::m2::Batch>>(m, "VectorM2Batch");
    py::bind_vector<std::vector<whiteout::m2::Bone>>(m, "VectorM2Bone");
    py::bind_vector<std::vector<whiteout::m2::BoneOverride>>(m, "VectorM2BoneOverride");
    py::bind_vector<std::vector<whiteout::m2::BoneOverrideSet>>(m, "VectorM2BoneOverrideSet");
    py::bind_vector<std::vector<whiteout::m2::BoxShape>>(m, "VectorM2BoxShape");
    py::bind_vector<std::vector<whiteout::m2::Camera>>(m, "VectorM2Camera");
    py::bind_vector<std::vector<whiteout::m2::CameraSpline>>(m, "VectorM2CameraSpline");
    py::bind_vector<std::vector<whiteout::m2::CapsuleShape>>(m, "VectorM2CapsuleShape");
    py::bind_vector<std::vector<whiteout::m2::ColorAnimation>>(m, "VectorM2ColorAnimation");
    py::bind_vector<std::vector<whiteout::m2::CompatQuaternion>>(m, "VectorM2CompatQuaternion");
    py::bind_vector<std::vector<whiteout::m2::DebugOcclusionData>>(m, "VectorM2DebugOcclusionData");
    py::bind_vector<std::vector<whiteout::m2::DetailedLightData>>(m, "VectorM2DetailedLightData");
    py::bind_vector<std::vector<whiteout::m2::DistanceFadeData>>(m, "VectorM2DistanceFadeData");
    py::bind_vector<std::vector<whiteout::m2::DistanceJoint>>(m, "VectorM2DistanceJoint");
    py::bind_vector<std::vector<whiteout::m2::EdgeFadeData>>(m, "VectorM2EdgeFadeData");
    py::bind_vector<std::vector<whiteout::m2::Event>>(m, "VectorM2Event");
    py::bind_vector<std::vector<whiteout::m2::Extent>>(m, "VectorM2Extent");
    py::bind_vector<std::vector<whiteout::m2::GlobalSequence>>(m, "VectorM2GlobalSequence");
    py::bind_vector<std::vector<whiteout::m2::Light>>(m, "VectorM2Light");
    py::bind_vector<std::vector<whiteout::m2::Material>>(m, "VectorM2Material");
    py::bind_vector<std::vector<whiteout::m2::ParticleEmitter>>(m, "VectorM2ParticleEmitter");
    py::bind_vector<std::vector<whiteout::m2::ParticleGeosetData>>(m, "VectorM2ParticleGeosetData");
    py::bind_vector<std::vector<whiteout::m2::PhysicsBody>>(m, "VectorM2PhysicsBody");
    py::bind_vector<std::vector<whiteout::m2::PhysicsJoint>>(m, "VectorM2PhysicsJoint");
    py::bind_vector<std::vector<whiteout::m2::PhysicsShape>>(m, "VectorM2PhysicsShape");
    py::bind_vector<std::vector<whiteout::m2::PhysicsTuning>>(m, "VectorM2PhysicsTuning");
    py::bind_vector<std::vector<whiteout::m2::PivotDisplacementData>>(m, "VectorM2PivotDisplacementData");
    py::bind_vector<std::vector<whiteout::m2::PolytopeHalfEdge>>(m, "VectorM2PolytopeHalfEdge");
    py::bind_vector<std::vector<whiteout::m2::PolytopeShape>>(m, "VectorM2PolytopeShape");
    py::bind_vector<std::vector<whiteout::m2::PrismaticJoint>>(m, "VectorM2PrismaticJoint");
    py::bind_vector<std::vector<whiteout::m2::RevoluteJoint>>(m, "VectorM2RevoluteJoint");
    py::bind_vector<std::vector<whiteout::m2::RibbonEmitter>>(m, "VectorM2RibbonEmitter");
    py::bind_vector<std::vector<whiteout::m2::Sequence>>(m, "VectorM2Sequence");
    py::bind_vector<std::vector<whiteout::m2::ShadowBatch>>(m, "VectorM2ShadowBatch");
    py::bind_vector<std::vector<whiteout::m2::ShoulderJoint>>(m, "VectorM2ShoulderJoint");
    py::bind_vector<std::vector<whiteout::m2::SkinProfile>>(m, "VectorM2SkinProfile");
    py::bind_vector<std::vector<whiteout::m2::SkinSection>>(m, "VectorM2SkinSection");
    py::bind_vector<std::vector<whiteout::m2::SphereShape>>(m, "VectorM2SphereShape");
    py::bind_vector<std::vector<whiteout::m2::SphericalJoint>>(m, "VectorM2SphericalJoint");
    py::bind_vector<std::vector<whiteout::m2::Texture>>(m, "VectorM2Texture");
    py::bind_vector<std::vector<whiteout::m2::TextureTransform>>(m, "VectorM2TextureTransform");
    py::bind_vector<std::vector<whiteout::m2::TextureWeight>>(m, "VectorM2TextureWeight");
    py::bind_vector<std::vector<whiteout::m2::TexturedLightData>>(m, "VectorM2TexturedLightData");
    py::bind_vector<std::vector<whiteout::m2::Vertex>>(m, "VectorM2Vertex");
    py::bind_vector<std::vector<whiteout::m2::WeldJoint>>(m, "VectorM2WeldJoint");

}