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/skin.h>
#include <whiteout/models/m2/structures.h>
#include <whiteout/models/m2/parser.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::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::Vector2f>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::Vector3f>);
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::Camera>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::CameraSpline>);
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::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::RibbonEmitter>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::Sequence>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::ShadowBatch>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SkinProfile>);
PYBIND11_MAKE_OPAQUE(std::vector<whiteout::m2::SkinSection>);
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>);

#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("UNUSED", whiteout::m2::GlobalFlag::Unused)
        .value("UNK_0X80", whiteout::m2::GlobalFlag::Unk_0x80)
        .value("LOAD_PHYSICS_DATA", whiteout::m2::GlobalFlag::LoadPhysicsData)
        .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("SHADED", whiteout::m2::ParticleFlag::Shaded)
        .value("SORT_PARTICLES", whiteout::m2::ParticleFlag::SortParticles)
        .value("VELOCITY_ORIENT", whiteout::m2::ParticleFlag::VelocityOrient)
        .value("UNSHADED", whiteout::m2::ParticleFlag::Unshaded)
        .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("UNFOGGED", whiteout::m2::ParticleFlag::Unfogged)
        .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::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::CompatQuaternion>(m, "CompatQuaternion")
        .def(py::init<>())
    ;

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

    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("reserved0", &whiteout::m2::LodProfile::reserved0)
        .def_readwrite("lod_flags", &whiteout::m2::LodProfile::lodFlags)
        .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::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("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::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("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_file_data", &whiteout::m2::Model::physicsFileData, R"doc(PFDC)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)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("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)
    ;

    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")
        .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")
        .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")
        .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::f32>>(m, "AnimationTrackF32")
        .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")
        .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")
        .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")
        .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::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::Camera>>(m, "VectorM2Camera");
    py::bind_vector<std::vector<whiteout::m2::CameraSpline>>(m, "VectorM2CameraSpline");
    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::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::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::SkinProfile>>(m, "VectorM2SkinProfile");
    py::bind_vector<std::vector<whiteout::m2::SkinSection>>(m, "VectorM2SkinSection");
    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");

}