whiteoutlib 0.1.2

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

#include "whiteout_m2.h"

#include <cstring>
#include <new>
#include <span>
#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>

namespace { using namespace whiteout; }

namespace {

// `whiteout::u8` is `std::uint8_t`, so a single overload suffices. We use
// the project's type so the reinterpret_cast is a no-op everywhere the
// codegen runs.
inline whiteout_Bytes wrapBytes(std::vector<whiteout::u8>&& v) {
    auto* owned = new std::vector<whiteout::u8>(std::move(v));
    return { reinterpret_cast<const uint8_t*>(owned->data()), owned->size(), owned };
}

inline whiteout_Bytes emptyBytes() {
    return { nullptr, 0, nullptr };
}

inline whiteout_CString wrapCString(std::string&& s) {
    auto* owned = new std::string(std::move(s));
    return { owned->c_str(), owned->size(), owned };
}

inline whiteout_CString emptyCString() {
    return { nullptr, 0, nullptr };
}

} // anonymous
// ── M2CompatQuaternion ─────────────────────────────────────────────────

extern "C" {

whiteout_M2CompatQuaternion* whiteout_m2_M2CompatQuaternion_new(void) {
    return reinterpret_cast<whiteout_M2CompatQuaternion*>(new whiteout::m2::CompatQuaternion());
}

void whiteout_m2_M2CompatQuaternion_delete(whiteout_M2CompatQuaternion* self) {
    delete reinterpret_cast<whiteout::m2::CompatQuaternion*>(self);
}

} // extern "C"

// ── M2ColorBGRA ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ColorBGRA* whiteout_m2_M2ColorBGRA_new(void) {
    return reinterpret_cast<whiteout_M2ColorBGRA*>(new whiteout::m2::ColorBGRA());
}

void whiteout_m2_M2ColorBGRA_delete(whiteout_M2ColorBGRA* self) {
    delete reinterpret_cast<whiteout::m2::ColorBGRA*>(self);
}

} // extern "C"

// ── M2Extent ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Extent* whiteout_m2_M2Extent_new(void) {
    return reinterpret_cast<whiteout_M2Extent*>(new whiteout::m2::Extent());
}

void whiteout_m2_M2Extent_delete(whiteout_M2Extent* self) {
    delete reinterpret_cast<whiteout::m2::Extent*>(self);
}

whiteout_Vector3f* whiteout_m2_M2Extent_get_minimum(whiteout_M2Extent* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Extent*>(self)->minimum);
}

void whiteout_m2_M2Extent_set_minimum(whiteout_M2Extent* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Extent*>(self)->minimum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_m2_M2Extent_get_maximum(whiteout_M2Extent* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Extent*>(self)->maximum);
}

void whiteout_m2_M2Extent_set_maximum(whiteout_M2Extent* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Extent*>(self)->maximum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_m2_M2Extent_get_sphereRadius(const whiteout_M2Extent* self) {
    return reinterpret_cast<const whiteout::m2::Extent*>(self)->sphereRadius;
}

void whiteout_m2_M2Extent_set_sphereRadius(whiteout_M2Extent* self, float value) {
    reinterpret_cast<whiteout::m2::Extent*>(self)->sphereRadius = value;
}

} // extern "C"

// ── M2AnimationTrackBase ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackBase* whiteout_m2_M2AnimationTrackBase_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackBase*>(new whiteout::m2::AnimationTrackBase());
}

void whiteout_m2_M2AnimationTrackBase_delete(whiteout_M2AnimationTrackBase* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self);
}

int32_t whiteout_m2_M2AnimationTrackBase_get_interpolationType(const whiteout_M2AnimationTrackBase* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackBase_set_interpolationType(whiteout_M2AnimationTrackBase* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackBase_get_globalSequenceId(const whiteout_M2AnimationTrackBase* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackBase_set_globalSequenceId(whiteout_M2AnimationTrackBase* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackBase_get_timestamps_count(const whiteout_M2AnimationTrackBase* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_count(const whiteout_M2AnimationTrackBase* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackBase_resize_timestamps(whiteout_M2AnimationTrackBase* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackBase_resize_timestamps_inner(whiteout_M2AnimationTrackBase* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackBase_get_timestamps_inner_data(const whiteout_M2AnimationTrackBase* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackBase_assign_timestamps_inner(whiteout_M2AnimationTrackBase* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrackBase*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

} // extern "C"

// ── M2ParticleEmitterExtension ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ParticleEmitterExtension* whiteout_m2_M2ParticleEmitterExtension_new(void) {
    return reinterpret_cast<whiteout_M2ParticleEmitterExtension*>(new whiteout::m2::ParticleEmitterExtension());
}

void whiteout_m2_M2ParticleEmitterExtension_delete(whiteout_M2ParticleEmitterExtension* self) {
    delete reinterpret_cast<whiteout::m2::ParticleEmitterExtension*>(self);
}

float whiteout_m2_M2ParticleEmitterExtension_get_zSource(const whiteout_M2ParticleEmitterExtension* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitterExtension*>(self)->zSource;
}

void whiteout_m2_M2ParticleEmitterExtension_set_zSource(whiteout_M2ParticleEmitterExtension* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitterExtension*>(self)->zSource = value;
}

float whiteout_m2_M2ParticleEmitterExtension_get_colorMult(const whiteout_M2ParticleEmitterExtension* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitterExtension*>(self)->colorMult;
}

void whiteout_m2_M2ParticleEmitterExtension_set_colorMult(whiteout_M2ParticleEmitterExtension* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitterExtension*>(self)->colorMult = value;
}

float whiteout_m2_M2ParticleEmitterExtension_get_alphaMult(const whiteout_M2ParticleEmitterExtension* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitterExtension*>(self)->alphaMult;
}

void whiteout_m2_M2ParticleEmitterExtension_set_alphaMult(whiteout_M2ParticleEmitterExtension* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitterExtension*>(self)->alphaMult = value;
}

} // extern "C"

// ── M2LodProfile ─────────────────────────────────────────────────

extern "C" {

whiteout_M2LodProfile* whiteout_m2_M2LodProfile_new(void) {
    return reinterpret_cast<whiteout_M2LodProfile*>(new whiteout::m2::LodProfile());
}

void whiteout_m2_M2LodProfile_delete(whiteout_M2LodProfile* self) {
    delete reinterpret_cast<whiteout::m2::LodProfile*>(self);
}

uint16_t whiteout_m2_M2LodProfile_get_flags(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->flags;
}

void whiteout_m2_M2LodProfile_set_flags(whiteout_M2LodProfile* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->flags = value;
}

uint16_t whiteout_m2_M2LodProfile_get_numLodLevels(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->numLodLevels;
}

void whiteout_m2_M2LodProfile_set_numLodLevels(whiteout_M2LodProfile* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->numLodLevels = value;
}

float whiteout_m2_M2LodProfile_get_lodDistance(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->lodDistance;
}

void whiteout_m2_M2LodProfile_set_lodDistance(whiteout_M2LodProfile* self, float value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->lodDistance = value;
}

size_t whiteout_m2_M2LodProfile_particleBoneLod_size(void) {
    return 4;
}

uint8_t whiteout_m2_M2LodProfile_get_particleBoneLod_at(const whiteout_M2LodProfile* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->particleBoneLod[index];
}

void whiteout_m2_M2LodProfile_set_particleBoneLod_at(whiteout_M2LodProfile* self, size_t index, uint8_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->particleBoneLod[index] = value;
}

uint8_t whiteout_m2_M2LodProfile_get_reserved0(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->reserved0;
}

void whiteout_m2_M2LodProfile_set_reserved0(whiteout_M2LodProfile* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->reserved0 = value;
}

uint8_t whiteout_m2_M2LodProfile_get_lodFlags(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->lodFlags;
}

void whiteout_m2_M2LodProfile_set_lodFlags(whiteout_M2LodProfile* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->lodFlags = value;
}

uint8_t whiteout_m2_M2LodProfile_get_lodBatchCount(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->lodBatchCount;
}

void whiteout_m2_M2LodProfile_set_lodBatchCount(whiteout_M2LodProfile* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->lodBatchCount = value;
}

uint8_t whiteout_m2_M2LodProfile_get_reserved1(const whiteout_M2LodProfile* self) {
    return reinterpret_cast<const whiteout::m2::LodProfile*>(self)->reserved1;
}

void whiteout_m2_M2LodProfile_set_reserved1(whiteout_M2LodProfile* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::LodProfile*>(self)->reserved1 = value;
}

} // extern "C"

// ── M2WaterfallData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2WaterfallData* whiteout_m2_M2WaterfallData_new(void) {
    return reinterpret_cast<whiteout_M2WaterfallData*>(new whiteout::m2::WaterfallData());
}

void whiteout_m2_M2WaterfallData_delete(whiteout_M2WaterfallData* self) {
    delete reinterpret_cast<whiteout::m2::WaterfallData*>(self);
}

float whiteout_m2_M2WaterfallData_get_bumpScale(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->bumpScale;
}

void whiteout_m2_M2WaterfallData_set_bumpScale(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->bumpScale = value;
}

float whiteout_m2_M2WaterfallData_get_value0_x(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value0_x;
}

void whiteout_m2_M2WaterfallData_set_value0_x(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value0_x = value;
}

float whiteout_m2_M2WaterfallData_get_value0_y(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value0_y;
}

void whiteout_m2_M2WaterfallData_set_value0_y(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value0_y = value;
}

float whiteout_m2_M2WaterfallData_get_value0_z(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value0_z;
}

void whiteout_m2_M2WaterfallData_set_value0_z(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value0_z = value;
}

float whiteout_m2_M2WaterfallData_get_value1_w(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value1_w;
}

void whiteout_m2_M2WaterfallData_set_value1_w(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value1_w = value;
}

float whiteout_m2_M2WaterfallData_get_value0_w(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value0_w;
}

void whiteout_m2_M2WaterfallData_set_value0_w(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value0_w = value;
}

float whiteout_m2_M2WaterfallData_get_value1_x(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value1_x;
}

void whiteout_m2_M2WaterfallData_set_value1_x(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value1_x = value;
}

float whiteout_m2_M2WaterfallData_get_value1_y(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value1_y;
}

void whiteout_m2_M2WaterfallData_set_value1_y(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value1_y = value;
}

float whiteout_m2_M2WaterfallData_get_value2_w(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value2_w;
}

void whiteout_m2_M2WaterfallData_set_value2_w(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value2_w = value;
}

float whiteout_m2_M2WaterfallData_get_value3_y(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value3_y;
}

void whiteout_m2_M2WaterfallData_set_value3_y(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value3_y = value;
}

float whiteout_m2_M2WaterfallData_get_value3_x(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value3_x;
}

void whiteout_m2_M2WaterfallData_set_value3_x(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value3_x = value;
}

whiteout_Vector4f* whiteout_m2_M2WaterfallData_get_baseColor(whiteout_M2WaterfallData* self) {
    return reinterpret_cast<whiteout_Vector4f*>(&reinterpret_cast<whiteout::m2::WaterfallData*>(self)->baseColor);
}

void whiteout_m2_M2WaterfallData_set_baseColor(whiteout_M2WaterfallData* self, const whiteout_Vector4f* value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->baseColor = *reinterpret_cast<const whiteout::Vector4f*>(value);
}

uint16_t whiteout_m2_M2WaterfallData_get_flags(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->flags;
}

void whiteout_m2_M2WaterfallData_set_flags(whiteout_M2WaterfallData* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->flags = value;
}

uint16_t whiteout_m2_M2WaterfallData_get_unknown0(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->unknown0;
}

void whiteout_m2_M2WaterfallData_set_unknown0(whiteout_M2WaterfallData* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->unknown0 = value;
}

float whiteout_m2_M2WaterfallData_get_value3_w(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value3_w;
}

void whiteout_m2_M2WaterfallData_set_value3_w(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value3_w = value;
}

float whiteout_m2_M2WaterfallData_get_value3_z(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value3_z;
}

void whiteout_m2_M2WaterfallData_set_value3_z(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value3_z = value;
}

float whiteout_m2_M2WaterfallData_get_value4_y(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->value4_y;
}

void whiteout_m2_M2WaterfallData_set_value4_y(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->value4_y = value;
}

float whiteout_m2_M2WaterfallData_get_unknown1(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->unknown1;
}

void whiteout_m2_M2WaterfallData_set_unknown1(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->unknown1 = value;
}

float whiteout_m2_M2WaterfallData_get_unknown2(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->unknown2;
}

void whiteout_m2_M2WaterfallData_set_unknown2(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->unknown2 = value;
}

float whiteout_m2_M2WaterfallData_get_unknown3(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->unknown3;
}

void whiteout_m2_M2WaterfallData_set_unknown3(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->unknown3 = value;
}

float whiteout_m2_M2WaterfallData_get_unknown4(const whiteout_M2WaterfallData* self) {
    return reinterpret_cast<const whiteout::m2::WaterfallData*>(self)->unknown4;
}

void whiteout_m2_M2WaterfallData_set_unknown4(whiteout_M2WaterfallData* self, float value) {
    reinterpret_cast<whiteout::m2::WaterfallData*>(self)->unknown4 = value;
}

} // extern "C"

// ── M2ParticleGeosetData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ParticleGeosetData* whiteout_m2_M2ParticleGeosetData_new(void) {
    return reinterpret_cast<whiteout_M2ParticleGeosetData*>(new whiteout::m2::ParticleGeosetData());
}

void whiteout_m2_M2ParticleGeosetData_delete(whiteout_M2ParticleGeosetData* self) {
    delete reinterpret_cast<whiteout::m2::ParticleGeosetData*>(self);
}

uint16_t whiteout_m2_M2ParticleGeosetData_get_geoset(const whiteout_M2ParticleGeosetData* self) {
    return reinterpret_cast<const whiteout::m2::ParticleGeosetData*>(self)->geoset;
}

void whiteout_m2_M2ParticleGeosetData_set_geoset(whiteout_M2ParticleGeosetData* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ParticleGeosetData*>(self)->geoset = value;
}

} // extern "C"

// ── M2EdgeFadeData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2EdgeFadeData* whiteout_m2_M2EdgeFadeData_new(void) {
    return reinterpret_cast<whiteout_M2EdgeFadeData*>(new whiteout::m2::EdgeFadeData());
}

void whiteout_m2_M2EdgeFadeData_delete(whiteout_M2EdgeFadeData* self) {
    delete reinterpret_cast<whiteout::m2::EdgeFadeData*>(self);
}

size_t whiteout_m2_M2EdgeFadeData_value0_size(void) {
    return 2;
}

float whiteout_m2_M2EdgeFadeData_get_value0_at(const whiteout_M2EdgeFadeData* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::EdgeFadeData*>(self)->value0[index];
}

void whiteout_m2_M2EdgeFadeData_set_value0_at(whiteout_M2EdgeFadeData* self, size_t index, float value) {
    reinterpret_cast<whiteout::m2::EdgeFadeData*>(self)->value0[index] = value;
}

float whiteout_m2_M2EdgeFadeData_get_value8(const whiteout_M2EdgeFadeData* self) {
    return reinterpret_cast<const whiteout::m2::EdgeFadeData*>(self)->value8;
}

void whiteout_m2_M2EdgeFadeData_set_value8(whiteout_M2EdgeFadeData* self, float value) {
    reinterpret_cast<whiteout::m2::EdgeFadeData*>(self)->value8 = value;
}

size_t whiteout_m2_M2EdgeFadeData_valueC_size(void) {
    return 12;
}

uint8_t whiteout_m2_M2EdgeFadeData_get_valueC_at(const whiteout_M2EdgeFadeData* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::EdgeFadeData*>(self)->valueC[index];
}

void whiteout_m2_M2EdgeFadeData_set_valueC_at(whiteout_M2EdgeFadeData* self, size_t index, uint8_t value) {
    reinterpret_cast<whiteout::m2::EdgeFadeData*>(self)->valueC[index] = value;
}

} // extern "C"

// ── M2DistanceFadeData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2DistanceFadeData* whiteout_m2_M2DistanceFadeData_new(void) {
    return reinterpret_cast<whiteout_M2DistanceFadeData*>(new whiteout::m2::DistanceFadeData());
}

void whiteout_m2_M2DistanceFadeData_delete(whiteout_M2DistanceFadeData* self) {
    delete reinterpret_cast<whiteout::m2::DistanceFadeData*>(self);
}

float whiteout_m2_M2DistanceFadeData_get_squaredFarDist(const whiteout_M2DistanceFadeData* self) {
    return reinterpret_cast<const whiteout::m2::DistanceFadeData*>(self)->squaredFarDist;
}

void whiteout_m2_M2DistanceFadeData_set_squaredFarDist(whiteout_M2DistanceFadeData* self, float value) {
    reinterpret_cast<whiteout::m2::DistanceFadeData*>(self)->squaredFarDist = value;
}

float whiteout_m2_M2DistanceFadeData_get_squaredNearDist(const whiteout_M2DistanceFadeData* self) {
    return reinterpret_cast<const whiteout::m2::DistanceFadeData*>(self)->squaredNearDist;
}

void whiteout_m2_M2DistanceFadeData_set_squaredNearDist(whiteout_M2DistanceFadeData* self, float value) {
    reinterpret_cast<whiteout::m2::DistanceFadeData*>(self)->squaredNearDist = value;
}

size_t whiteout_m2_M2DistanceFadeData_reserved_size(void) {
    return 2;
}

uint32_t whiteout_m2_M2DistanceFadeData_get_reserved_at(const whiteout_M2DistanceFadeData* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::DistanceFadeData*>(self)->reserved[index];
}

void whiteout_m2_M2DistanceFadeData_set_reserved_at(whiteout_M2DistanceFadeData* self, size_t index, uint32_t value) {
    reinterpret_cast<whiteout::m2::DistanceFadeData*>(self)->reserved[index] = value;
}

} // extern "C"

// ── M2DetailedLightData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2DetailedLightData* whiteout_m2_M2DetailedLightData_new(void) {
    return reinterpret_cast<whiteout_M2DetailedLightData*>(new whiteout::m2::DetailedLightData());
}

void whiteout_m2_M2DetailedLightData_delete(whiteout_M2DetailedLightData* self) {
    delete reinterpret_cast<whiteout::m2::DetailedLightData*>(self);
}

uint16_t whiteout_m2_M2DetailedLightData_get_flags(const whiteout_M2DetailedLightData* self) {
    return reinterpret_cast<const whiteout::m2::DetailedLightData*>(self)->flags;
}

void whiteout_m2_M2DetailedLightData_set_flags(whiteout_M2DetailedLightData* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::DetailedLightData*>(self)->flags = value;
}

uint16_t whiteout_m2_M2DetailedLightData_get_unknown0(const whiteout_M2DetailedLightData* self) {
    return reinterpret_cast<const whiteout::m2::DetailedLightData*>(self)->unknown0;
}

void whiteout_m2_M2DetailedLightData_set_unknown0(whiteout_M2DetailedLightData* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::DetailedLightData*>(self)->unknown0 = value;
}

uint32_t whiteout_m2_M2DetailedLightData_get_unknown1(const whiteout_M2DetailedLightData* self) {
    return reinterpret_cast<const whiteout::m2::DetailedLightData*>(self)->unknown1;
}

void whiteout_m2_M2DetailedLightData_set_unknown1(whiteout_M2DetailedLightData* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::DetailedLightData*>(self)->unknown1 = value;
}

} // extern "C"

// ── M2DebugOcclusionData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2DebugOcclusionData* whiteout_m2_M2DebugOcclusionData_new(void) {
    return reinterpret_cast<whiteout_M2DebugOcclusionData*>(new whiteout::m2::DebugOcclusionData());
}

void whiteout_m2_M2DebugOcclusionData_delete(whiteout_M2DebugOcclusionData* self) {
    delete reinterpret_cast<whiteout::m2::DebugOcclusionData*>(self);
}

float whiteout_m2_M2DebugOcclusionData_get_unknown1_1(const whiteout_M2DebugOcclusionData* self) {
    return reinterpret_cast<const whiteout::m2::DebugOcclusionData*>(self)->unknown1_1;
}

void whiteout_m2_M2DebugOcclusionData_set_unknown1_1(whiteout_M2DebugOcclusionData* self, float value) {
    reinterpret_cast<whiteout::m2::DebugOcclusionData*>(self)->unknown1_1 = value;
}

float whiteout_m2_M2DebugOcclusionData_get_unknown1_2(const whiteout_M2DebugOcclusionData* self) {
    return reinterpret_cast<const whiteout::m2::DebugOcclusionData*>(self)->unknown1_2;
}

void whiteout_m2_M2DebugOcclusionData_set_unknown1_2(whiteout_M2DebugOcclusionData* self, float value) {
    reinterpret_cast<whiteout::m2::DebugOcclusionData*>(self)->unknown1_2 = value;
}

uint32_t whiteout_m2_M2DebugOcclusionData_get_unknown1_3(const whiteout_M2DebugOcclusionData* self) {
    return reinterpret_cast<const whiteout::m2::DebugOcclusionData*>(self)->unknown1_3;
}

void whiteout_m2_M2DebugOcclusionData_set_unknown1_3(whiteout_M2DebugOcclusionData* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::DebugOcclusionData*>(self)->unknown1_3 = value;
}

uint32_t whiteout_m2_M2DebugOcclusionData_get_unknown1_4(const whiteout_M2DebugOcclusionData* self) {
    return reinterpret_cast<const whiteout::m2::DebugOcclusionData*>(self)->unknown1_4;
}

void whiteout_m2_M2DebugOcclusionData_set_unknown1_4(whiteout_M2DebugOcclusionData* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::DebugOcclusionData*>(self)->unknown1_4 = value;
}

} // extern "C"

// ── M2TexturedLightData ─────────────────────────────────────────────────

extern "C" {

whiteout_M2TexturedLightData* whiteout_m2_M2TexturedLightData_new(void) {
    return reinterpret_cast<whiteout_M2TexturedLightData*>(new whiteout::m2::TexturedLightData());
}

void whiteout_m2_M2TexturedLightData_delete(whiteout_M2TexturedLightData* self) {
    delete reinterpret_cast<whiteout::m2::TexturedLightData*>(self);
}

float whiteout_m2_M2TexturedLightData_get_unknown0(const whiteout_M2TexturedLightData* self) {
    return reinterpret_cast<const whiteout::m2::TexturedLightData*>(self)->unknown0;
}

void whiteout_m2_M2TexturedLightData_set_unknown0(whiteout_M2TexturedLightData* self, float value) {
    reinterpret_cast<whiteout::m2::TexturedLightData*>(self)->unknown0 = value;
}

float whiteout_m2_M2TexturedLightData_get_unknown1(const whiteout_M2TexturedLightData* self) {
    return reinterpret_cast<const whiteout::m2::TexturedLightData*>(self)->unknown1;
}

void whiteout_m2_M2TexturedLightData_set_unknown1(whiteout_M2TexturedLightData* self, float value) {
    reinterpret_cast<whiteout::m2::TexturedLightData*>(self)->unknown1 = value;
}

int32_t whiteout_m2_M2TexturedLightData_get_textureLookup(const whiteout_M2TexturedLightData* self) {
    return reinterpret_cast<const whiteout::m2::TexturedLightData*>(self)->textureLookup;
}

void whiteout_m2_M2TexturedLightData_set_textureLookup(whiteout_M2TexturedLightData* self, int32_t value) {
    reinterpret_cast<whiteout::m2::TexturedLightData*>(self)->textureLookup = value;
}

int32_t whiteout_m2_M2TexturedLightData_get_unknown2(const whiteout_M2TexturedLightData* self) {
    return reinterpret_cast<const whiteout::m2::TexturedLightData*>(self)->unknown2;
}

void whiteout_m2_M2TexturedLightData_set_unknown2(whiteout_M2TexturedLightData* self, int32_t value) {
    reinterpret_cast<whiteout::m2::TexturedLightData*>(self)->unknown2 = value;
}

} // extern "C"

// ── M2PhysicsCollision ─────────────────────────────────────────────────

extern "C" {

whiteout_M2PhysicsCollision* whiteout_m2_M2PhysicsCollision_new(void) {
    return reinterpret_cast<whiteout_M2PhysicsCollision*>(new whiteout::m2::PhysicsCollision());
}

void whiteout_m2_M2PhysicsCollision_delete(whiteout_M2PhysicsCollision* self) {
    delete reinterpret_cast<whiteout::m2::PhysicsCollision*>(self);
}

size_t whiteout_m2_M2PhysicsCollision_get_vertexPositions_count(const whiteout_M2PhysicsCollision* self) {
    return reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->vertexPositions.size();
}

void whiteout_m2_M2PhysicsCollision_resize_vertexPositions(whiteout_M2PhysicsCollision* self, size_t count) {
    reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->vertexPositions.resize(count);
}

const float* whiteout_m2_M2PhysicsCollision_get_vertexPositions_data(const whiteout_M2PhysicsCollision* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->vertexPositions;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2PhysicsCollision_assign_vertexPositions(whiteout_M2PhysicsCollision* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->vertexPositions;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

size_t whiteout_m2_M2PhysicsCollision_get_faceNormals_count(const whiteout_M2PhysicsCollision* self) {
    return reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->faceNormals.size();
}

void whiteout_m2_M2PhysicsCollision_resize_faceNormals(whiteout_M2PhysicsCollision* self, size_t count) {
    reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->faceNormals.resize(count);
}

const float* whiteout_m2_M2PhysicsCollision_get_faceNormals_data(const whiteout_M2PhysicsCollision* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->faceNormals;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2PhysicsCollision_assign_faceNormals(whiteout_M2PhysicsCollision* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->faceNormals;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

size_t whiteout_m2_M2PhysicsCollision_get_indices_count(const whiteout_M2PhysicsCollision* self) {
    return reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->indices.size();
}

void whiteout_m2_M2PhysicsCollision_resize_indices(whiteout_M2PhysicsCollision* self, size_t count) {
    reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->indices.resize(count);
}

const int16_t* whiteout_m2_M2PhysicsCollision_get_indices_data(const whiteout_M2PhysicsCollision* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->indices;
    return __v.empty() ? nullptr : reinterpret_cast<const int16_t*>(__v.data());
}

void whiteout_m2_M2PhysicsCollision_assign_indices(whiteout_M2PhysicsCollision* self, const int16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->indices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::i16));
}

size_t whiteout_m2_M2PhysicsCollision_get_flags_count(const whiteout_M2PhysicsCollision* self) {
    return reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->flags.size();
}

void whiteout_m2_M2PhysicsCollision_resize_flags(whiteout_M2PhysicsCollision* self, size_t count) {
    reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->flags.resize(count);
}

const int16_t* whiteout_m2_M2PhysicsCollision_get_flags_data(const whiteout_M2PhysicsCollision* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::PhysicsCollision*>(self)->flags;
    return __v.empty() ? nullptr : reinterpret_cast<const int16_t*>(__v.data());
}

void whiteout_m2_M2PhysicsCollision_assign_flags(whiteout_M2PhysicsCollision* self, const int16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::PhysicsCollision*>(self)->flags;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::i16));
}

} // extern "C"

// ── M2SkinSection ─────────────────────────────────────────────────

extern "C" {

whiteout_M2SkinSection* whiteout_m2_M2SkinSection_new(void) {
    return reinterpret_cast<whiteout_M2SkinSection*>(new whiteout::m2::SkinSection());
}

void whiteout_m2_M2SkinSection_delete(whiteout_M2SkinSection* self) {
    delete reinterpret_cast<whiteout::m2::SkinSection*>(self);
}

uint16_t whiteout_m2_M2SkinSection_get_skinSectionId(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->skinSectionId;
}

void whiteout_m2_M2SkinSection_set_skinSectionId(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->skinSectionId = value;
}

uint16_t whiteout_m2_M2SkinSection_get_level(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->level;
}

void whiteout_m2_M2SkinSection_set_level(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->level = value;
}

uint16_t whiteout_m2_M2SkinSection_get_vertexStart(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->vertexStart;
}

void whiteout_m2_M2SkinSection_set_vertexStart(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->vertexStart = value;
}

uint16_t whiteout_m2_M2SkinSection_get_vertexCount(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->vertexCount;
}

void whiteout_m2_M2SkinSection_set_vertexCount(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->vertexCount = value;
}

uint16_t whiteout_m2_M2SkinSection_get_indexStart(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->indexStart;
}

void whiteout_m2_M2SkinSection_set_indexStart(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->indexStart = value;
}

uint16_t whiteout_m2_M2SkinSection_get_indexCount(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->indexCount;
}

void whiteout_m2_M2SkinSection_set_indexCount(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->indexCount = value;
}

uint16_t whiteout_m2_M2SkinSection_get_boneCount(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->boneCount;
}

void whiteout_m2_M2SkinSection_set_boneCount(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->boneCount = value;
}

uint16_t whiteout_m2_M2SkinSection_get_boneComboIndex(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->boneComboIndex;
}

void whiteout_m2_M2SkinSection_set_boneComboIndex(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->boneComboIndex = value;
}

uint16_t whiteout_m2_M2SkinSection_get_boneInfluences(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->boneInfluences;
}

void whiteout_m2_M2SkinSection_set_boneInfluences(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->boneInfluences = value;
}

uint16_t whiteout_m2_M2SkinSection_get_centerBoneIndex(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->centerBoneIndex;
}

void whiteout_m2_M2SkinSection_set_centerBoneIndex(whiteout_M2SkinSection* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->centerBoneIndex = value;
}

whiteout_Vector3f* whiteout_m2_M2SkinSection_get_centerPosition(whiteout_M2SkinSection* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::SkinSection*>(self)->centerPosition);
}

void whiteout_m2_M2SkinSection_set_centerPosition(whiteout_M2SkinSection* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->centerPosition = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_m2_M2SkinSection_get_sortCenterPosition(whiteout_M2SkinSection* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::SkinSection*>(self)->sortCenterPosition);
}

void whiteout_m2_M2SkinSection_set_sortCenterPosition(whiteout_M2SkinSection* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->sortCenterPosition = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_m2_M2SkinSection_get_sortRadius(const whiteout_M2SkinSection* self) {
    return reinterpret_cast<const whiteout::m2::SkinSection*>(self)->sortRadius;
}

void whiteout_m2_M2SkinSection_set_sortRadius(whiteout_M2SkinSection* self, float value) {
    reinterpret_cast<whiteout::m2::SkinSection*>(self)->sortRadius = value;
}

} // extern "C"

// ── M2Batch ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Batch* whiteout_m2_M2Batch_new(void) {
    return reinterpret_cast<whiteout_M2Batch*>(new whiteout::m2::Batch());
}

void whiteout_m2_M2Batch_delete(whiteout_M2Batch* self) {
    delete reinterpret_cast<whiteout::m2::Batch*>(self);
}

uint8_t whiteout_m2_M2Batch_get_flags(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->flags;
}

void whiteout_m2_M2Batch_set_flags(whiteout_M2Batch* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->flags = value;
}

int8_t whiteout_m2_M2Batch_get_priorityPlane(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->priorityPlane;
}

void whiteout_m2_M2Batch_set_priorityPlane(whiteout_M2Batch* self, int8_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->priorityPlane = value;
}

uint16_t whiteout_m2_M2Batch_get_shaderId(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->shaderId;
}

void whiteout_m2_M2Batch_set_shaderId(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->shaderId = value;
}

uint16_t whiteout_m2_M2Batch_get_skinSectionIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->skinSectionIndex;
}

void whiteout_m2_M2Batch_set_skinSectionIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->skinSectionIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_geosetIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->geosetIndex;
}

void whiteout_m2_M2Batch_set_geosetIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->geosetIndex = value;
}

int16_t whiteout_m2_M2Batch_get_colorIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->colorIndex;
}

void whiteout_m2_M2Batch_set_colorIndex(whiteout_M2Batch* self, int16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->colorIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_materialIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->materialIndex;
}

void whiteout_m2_M2Batch_set_materialIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->materialIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_materialLayer(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->materialLayer;
}

void whiteout_m2_M2Batch_set_materialLayer(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->materialLayer = value;
}

uint16_t whiteout_m2_M2Batch_get_textureCount(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->textureCount;
}

void whiteout_m2_M2Batch_set_textureCount(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->textureCount = value;
}

uint16_t whiteout_m2_M2Batch_get_textureComboIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->textureComboIndex;
}

void whiteout_m2_M2Batch_set_textureComboIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->textureComboIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_textureCoordComboIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->textureCoordComboIndex;
}

void whiteout_m2_M2Batch_set_textureCoordComboIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->textureCoordComboIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_textureWeightComboIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->textureWeightComboIndex;
}

void whiteout_m2_M2Batch_set_textureWeightComboIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->textureWeightComboIndex = value;
}

uint16_t whiteout_m2_M2Batch_get_textureTransformComboIndex(const whiteout_M2Batch* self) {
    return reinterpret_cast<const whiteout::m2::Batch*>(self)->textureTransformComboIndex;
}

void whiteout_m2_M2Batch_set_textureTransformComboIndex(whiteout_M2Batch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Batch*>(self)->textureTransformComboIndex = value;
}

} // extern "C"

// ── M2ShadowBatch ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ShadowBatch* whiteout_m2_M2ShadowBatch_new(void) {
    return reinterpret_cast<whiteout_M2ShadowBatch*>(new whiteout::m2::ShadowBatch());
}

void whiteout_m2_M2ShadowBatch_delete(whiteout_M2ShadowBatch* self) {
    delete reinterpret_cast<whiteout::m2::ShadowBatch*>(self);
}

uint8_t whiteout_m2_M2ShadowBatch_get_flags(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->flags;
}

void whiteout_m2_M2ShadowBatch_set_flags(whiteout_M2ShadowBatch* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->flags = value;
}

uint8_t whiteout_m2_M2ShadowBatch_get_flags2(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->flags2;
}

void whiteout_m2_M2ShadowBatch_set_flags2(whiteout_M2ShadowBatch* self, uint8_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->flags2 = value;
}

uint16_t whiteout_m2_M2ShadowBatch_get_unknown0(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->unknown0;
}

void whiteout_m2_M2ShadowBatch_set_unknown0(whiteout_M2ShadowBatch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->unknown0 = value;
}

uint16_t whiteout_m2_M2ShadowBatch_get_submeshId(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->submeshId;
}

void whiteout_m2_M2ShadowBatch_set_submeshId(whiteout_M2ShadowBatch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->submeshId = value;
}

uint16_t whiteout_m2_M2ShadowBatch_get_textureId(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->textureId;
}

void whiteout_m2_M2ShadowBatch_set_textureId(whiteout_M2ShadowBatch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->textureId = value;
}

uint16_t whiteout_m2_M2ShadowBatch_get_colorId(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->colorId;
}

void whiteout_m2_M2ShadowBatch_set_colorId(whiteout_M2ShadowBatch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->colorId = value;
}

uint16_t whiteout_m2_M2ShadowBatch_get_transparencyId(const whiteout_M2ShadowBatch* self) {
    return reinterpret_cast<const whiteout::m2::ShadowBatch*>(self)->transparencyId;
}

void whiteout_m2_M2ShadowBatch_set_transparencyId(whiteout_M2ShadowBatch* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ShadowBatch*>(self)->transparencyId = value;
}

} // extern "C"

// ── M2SkinProfile ─────────────────────────────────────────────────

extern "C" {

whiteout_M2SkinProfile* whiteout_m2_M2SkinProfile_new(void) {
    return reinterpret_cast<whiteout_M2SkinProfile*>(new whiteout::m2::SkinProfile());
}

void whiteout_m2_M2SkinProfile_delete(whiteout_M2SkinProfile* self) {
    delete reinterpret_cast<whiteout::m2::SkinProfile*>(self);
}

size_t whiteout_m2_M2SkinProfile_get_vertices_count(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->vertices.size();
}

void whiteout_m2_M2SkinProfile_resize_vertices(whiteout_M2SkinProfile* self, size_t count) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->vertices.resize(count);
}

const uint16_t* whiteout_m2_M2SkinProfile_get_vertices_data(const whiteout_M2SkinProfile* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->vertices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2SkinProfile_assign_vertices(whiteout_M2SkinProfile* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::SkinProfile*>(self)->vertices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2SkinProfile_get_indices_count(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->indices.size();
}

void whiteout_m2_M2SkinProfile_resize_indices(whiteout_M2SkinProfile* self, size_t count) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->indices.resize(count);
}

const uint16_t* whiteout_m2_M2SkinProfile_get_indices_data(const whiteout_M2SkinProfile* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->indices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2SkinProfile_assign_indices(whiteout_M2SkinProfile* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::SkinProfile*>(self)->indices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2SkinProfile_get_submeshes_count(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->submeshes.size();
}

void whiteout_m2_M2SkinProfile_resize_submeshes(whiteout_M2SkinProfile* self, size_t count) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->submeshes.resize(count);
}

whiteout_M2SkinSection* whiteout_m2_M2SkinProfile_get_submeshes_at(whiteout_M2SkinProfile* self, size_t index) {
    return reinterpret_cast<whiteout_M2SkinSection*>(&reinterpret_cast<whiteout::m2::SkinProfile*>(self)->submeshes[index]);
}

size_t whiteout_m2_M2SkinProfile_get_batches_count(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->batches.size();
}

void whiteout_m2_M2SkinProfile_resize_batches(whiteout_M2SkinProfile* self, size_t count) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->batches.resize(count);
}

whiteout_M2Batch* whiteout_m2_M2SkinProfile_get_batches_at(whiteout_M2SkinProfile* self, size_t index) {
    return reinterpret_cast<whiteout_M2Batch*>(&reinterpret_cast<whiteout::m2::SkinProfile*>(self)->batches[index]);
}

uint32_t whiteout_m2_M2SkinProfile_get_lodVertexBase(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->lodVertexBase;
}

void whiteout_m2_M2SkinProfile_set_lodVertexBase(whiteout_M2SkinProfile* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->lodVertexBase = value;
}

size_t whiteout_m2_M2SkinProfile_get_shadowBatches_count(const whiteout_M2SkinProfile* self) {
    return reinterpret_cast<const whiteout::m2::SkinProfile*>(self)->shadowBatches.size();
}

void whiteout_m2_M2SkinProfile_resize_shadowBatches(whiteout_M2SkinProfile* self, size_t count) {
    reinterpret_cast<whiteout::m2::SkinProfile*>(self)->shadowBatches.resize(count);
}

whiteout_M2ShadowBatch* whiteout_m2_M2SkinProfile_get_shadowBatches_at(whiteout_M2SkinProfile* self, size_t index) {
    return reinterpret_cast<whiteout_M2ShadowBatch*>(&reinterpret_cast<whiteout::m2::SkinProfile*>(self)->shadowBatches[index]);
}

} // extern "C"

// ── M2GlobalFlags ─────────────────────────────────────────────────

extern "C" {

whiteout_M2GlobalFlags* whiteout_m2_M2GlobalFlags_new(void) {
    return reinterpret_cast<whiteout_M2GlobalFlags*>(new whiteout::m2::GlobalFlags());
}

void whiteout_m2_M2GlobalFlags_delete(whiteout_M2GlobalFlags* self) {
    delete reinterpret_cast<whiteout::m2::GlobalFlags*>(self);
}

int32_t whiteout_m2_M2GlobalFlags_get_value(const whiteout_M2GlobalFlags* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::GlobalFlags*>(self)->value);
}

void whiteout_m2_M2GlobalFlags_set_value(whiteout_M2GlobalFlags* self, int32_t value) {
    reinterpret_cast<whiteout::m2::GlobalFlags*>(self)->value = static_cast<whiteout::m2::GlobalFlag>(value);
}

} // extern "C"

// ── M2GlobalSequence ─────────────────────────────────────────────────

extern "C" {

whiteout_M2GlobalSequence* whiteout_m2_M2GlobalSequence_new(void) {
    return reinterpret_cast<whiteout_M2GlobalSequence*>(new whiteout::m2::GlobalSequence());
}

void whiteout_m2_M2GlobalSequence_delete(whiteout_M2GlobalSequence* self) {
    delete reinterpret_cast<whiteout::m2::GlobalSequence*>(self);
}

uint32_t whiteout_m2_M2GlobalSequence_get_timestamp(const whiteout_M2GlobalSequence* self) {
    return reinterpret_cast<const whiteout::m2::GlobalSequence*>(self)->timestamp;
}

void whiteout_m2_M2GlobalSequence_set_timestamp(whiteout_M2GlobalSequence* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::GlobalSequence*>(self)->timestamp = value;
}

} // extern "C"

// ── M2Sequence ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Sequence* whiteout_m2_M2Sequence_new(void) {
    return reinterpret_cast<whiteout_M2Sequence*>(new whiteout::m2::Sequence());
}

void whiteout_m2_M2Sequence_delete(whiteout_M2Sequence* self) {
    delete reinterpret_cast<whiteout::m2::Sequence*>(self);
}

uint16_t whiteout_m2_M2Sequence_get_id(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->id;
}

void whiteout_m2_M2Sequence_set_id(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->id = value;
}

uint16_t whiteout_m2_M2Sequence_get_variationIndex(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->variationIndex;
}

void whiteout_m2_M2Sequence_set_variationIndex(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->variationIndex = value;
}

uint32_t whiteout_m2_M2Sequence_get_duration(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->duration;
}

void whiteout_m2_M2Sequence_set_duration(whiteout_M2Sequence* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->duration = value;
}

float whiteout_m2_M2Sequence_get_movespeed(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->movespeed;
}

void whiteout_m2_M2Sequence_set_movespeed(whiteout_M2Sequence* self, float value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->movespeed = value;
}

int32_t whiteout_m2_M2Sequence_get_flags(const whiteout_M2Sequence* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::Sequence*>(self)->flags);
}

void whiteout_m2_M2Sequence_set_flags(whiteout_M2Sequence* self, int32_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->flags = static_cast<whiteout::m2::SequenceFlag>(value);
}

int16_t whiteout_m2_M2Sequence_get_frequency(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->frequency;
}

void whiteout_m2_M2Sequence_set_frequency(whiteout_M2Sequence* self, int16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->frequency = value;
}

uint16_t whiteout_m2_M2Sequence_get_padding(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->padding;
}

void whiteout_m2_M2Sequence_set_padding(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->padding = value;
}

uint32_t whiteout_m2_M2Sequence_get_replayMin(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->replayMin;
}

void whiteout_m2_M2Sequence_set_replayMin(whiteout_M2Sequence* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->replayMin = value;
}

uint32_t whiteout_m2_M2Sequence_get_replayMax(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->replayMax;
}

void whiteout_m2_M2Sequence_set_replayMax(whiteout_M2Sequence* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->replayMax = value;
}

uint16_t whiteout_m2_M2Sequence_get_blendTimeIn(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->blendTimeIn;
}

void whiteout_m2_M2Sequence_set_blendTimeIn(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->blendTimeIn = value;
}

uint16_t whiteout_m2_M2Sequence_get_blendTimeOut(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->blendTimeOut;
}

void whiteout_m2_M2Sequence_set_blendTimeOut(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->blendTimeOut = value;
}

whiteout_M2Extent* whiteout_m2_M2Sequence_get_bounding(whiteout_M2Sequence* self) {
    return reinterpret_cast<whiteout_M2Extent*>(&reinterpret_cast<whiteout::m2::Sequence*>(self)->bounding);
}

void whiteout_m2_M2Sequence_set_bounding(whiteout_M2Sequence* self, const whiteout_M2Extent* value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->bounding = *reinterpret_cast<const whiteout::m2::Extent*>(value);
}

int16_t whiteout_m2_M2Sequence_get_variationNext(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->variationNext;
}

void whiteout_m2_M2Sequence_set_variationNext(whiteout_M2Sequence* self, int16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->variationNext = value;
}

uint16_t whiteout_m2_M2Sequence_get_aliasNext(const whiteout_M2Sequence* self) {
    return reinterpret_cast<const whiteout::m2::Sequence*>(self)->aliasNext;
}

void whiteout_m2_M2Sequence_set_aliasNext(whiteout_M2Sequence* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Sequence*>(self)->aliasNext = value;
}

} // extern "C"

// ── M2Vertex ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Vertex* whiteout_m2_M2Vertex_new(void) {
    return reinterpret_cast<whiteout_M2Vertex*>(new whiteout::m2::Vertex());
}

void whiteout_m2_M2Vertex_delete(whiteout_M2Vertex* self) {
    delete reinterpret_cast<whiteout::m2::Vertex*>(self);
}

whiteout_Vector3f* whiteout_m2_M2Vertex_get_position(whiteout_M2Vertex* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Vertex*>(self)->position);
}

void whiteout_m2_M2Vertex_set_position(whiteout_M2Vertex* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Vertex*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

size_t whiteout_m2_M2Vertex_boneWeights_size(void) {
    return 4;
}

uint8_t whiteout_m2_M2Vertex_get_boneWeights_at(const whiteout_M2Vertex* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::Vertex*>(self)->boneWeights[index];
}

void whiteout_m2_M2Vertex_set_boneWeights_at(whiteout_M2Vertex* self, size_t index, uint8_t value) {
    reinterpret_cast<whiteout::m2::Vertex*>(self)->boneWeights[index] = value;
}

size_t whiteout_m2_M2Vertex_boneIndices_size(void) {
    return 4;
}

uint8_t whiteout_m2_M2Vertex_get_boneIndices_at(const whiteout_M2Vertex* self, size_t index) {
    return reinterpret_cast<const whiteout::m2::Vertex*>(self)->boneIndices[index];
}

void whiteout_m2_M2Vertex_set_boneIndices_at(whiteout_M2Vertex* self, size_t index, uint8_t value) {
    reinterpret_cast<whiteout::m2::Vertex*>(self)->boneIndices[index] = value;
}

whiteout_Vector3f* whiteout_m2_M2Vertex_get_normal(whiteout_M2Vertex* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Vertex*>(self)->normal);
}

void whiteout_m2_M2Vertex_set_normal(whiteout_M2Vertex* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Vertex*>(self)->normal = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

size_t whiteout_m2_M2Vertex_texCoords_size(void) {
    return 2;
}

whiteout_Vector2f* whiteout_m2_M2Vertex_get_texCoords_at(const whiteout_M2Vertex* self, size_t index) {
    return const_cast<whiteout_Vector2f*>(reinterpret_cast<const whiteout_Vector2f*>(&reinterpret_cast<const whiteout::m2::Vertex*>(self)->texCoords[index]));
}

} // extern "C"

// ── M2Bone ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Bone* whiteout_m2_M2Bone_new(void) {
    return reinterpret_cast<whiteout_M2Bone*>(new whiteout::m2::Bone());
}

void whiteout_m2_M2Bone_delete(whiteout_M2Bone* self) {
    delete reinterpret_cast<whiteout::m2::Bone*>(self);
}

int32_t whiteout_m2_M2Bone_get_keyBoneId(const whiteout_M2Bone* self) {
    return reinterpret_cast<const whiteout::m2::Bone*>(self)->keyBoneId;
}

void whiteout_m2_M2Bone_set_keyBoneId(whiteout_M2Bone* self, int32_t value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->keyBoneId = value;
}

uint32_t whiteout_m2_M2Bone_get_flags(const whiteout_M2Bone* self) {
    return reinterpret_cast<const whiteout::m2::Bone*>(self)->flags;
}

void whiteout_m2_M2Bone_set_flags(whiteout_M2Bone* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->flags = value;
}

int16_t whiteout_m2_M2Bone_get_parentBoneId(const whiteout_M2Bone* self) {
    return reinterpret_cast<const whiteout::m2::Bone*>(self)->parentBoneId;
}

void whiteout_m2_M2Bone_set_parentBoneId(whiteout_M2Bone* self, int16_t value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->parentBoneId = value;
}

uint16_t whiteout_m2_M2Bone_get_submeshId(const whiteout_M2Bone* self) {
    return reinterpret_cast<const whiteout::m2::Bone*>(self)->submeshId;
}

void whiteout_m2_M2Bone_set_submeshId(whiteout_M2Bone* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->submeshId = value;
}

uint32_t whiteout_m2_M2Bone_get_boneNameCRC(const whiteout_M2Bone* self) {
    return reinterpret_cast<const whiteout::m2::Bone*>(self)->boneNameCRC;
}

void whiteout_m2_M2Bone_set_boneNameCRC(whiteout_M2Bone* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->boneNameCRC = value;
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2Bone_get_translation(whiteout_M2Bone* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::Bone*>(self)->translation);
}

void whiteout_m2_M2Bone_set_translation(whiteout_M2Bone* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->translation = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackM2CompatQuaternion* whiteout_m2_M2Bone_get_rotation(whiteout_M2Bone* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CompatQuaternion*>(&reinterpret_cast<whiteout::m2::Bone*>(self)->rotation);
}

void whiteout_m2_M2Bone_set_rotation(whiteout_M2Bone* self, const whiteout_M2AnimationTrackM2CompatQuaternion* value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->rotation = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(value);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2Bone_get_scale(whiteout_M2Bone* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::Bone*>(self)->scale);
}

void whiteout_m2_M2Bone_set_scale(whiteout_M2Bone* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->scale = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_Vector3f* whiteout_m2_M2Bone_get_pivot(whiteout_M2Bone* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Bone*>(self)->pivot);
}

void whiteout_m2_M2Bone_set_pivot(whiteout_M2Bone* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Bone*>(self)->pivot = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

} // extern "C"

// ── M2Texture ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Texture* whiteout_m2_M2Texture_new(void) {
    return reinterpret_cast<whiteout_M2Texture*>(new whiteout::m2::Texture());
}

void whiteout_m2_M2Texture_delete(whiteout_M2Texture* self) {
    delete reinterpret_cast<whiteout::m2::Texture*>(self);
}

uint32_t whiteout_m2_M2Texture_get_type(const whiteout_M2Texture* self) {
    return reinterpret_cast<const whiteout::m2::Texture*>(self)->type;
}

void whiteout_m2_M2Texture_set_type(whiteout_M2Texture* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Texture*>(self)->type = value;
}

uint32_t whiteout_m2_M2Texture_get_flags(const whiteout_M2Texture* self) {
    return reinterpret_cast<const whiteout::m2::Texture*>(self)->flags;
}

void whiteout_m2_M2Texture_set_flags(whiteout_M2Texture* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Texture*>(self)->flags = value;
}

whiteout_CString whiteout_m2_M2Texture_get_filename(const whiteout_M2Texture* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::m2::Texture*>(self)->filename);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_m2_M2Texture_set_filename(whiteout_M2Texture* self, const char* value) {
    reinterpret_cast<whiteout::m2::Texture*>(self)->filename = (value ? value : "");
}

} // extern "C"

// ── M2Material ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Material* whiteout_m2_M2Material_new(void) {
    return reinterpret_cast<whiteout_M2Material*>(new whiteout::m2::Material());
}

void whiteout_m2_M2Material_delete(whiteout_M2Material* self) {
    delete reinterpret_cast<whiteout::m2::Material*>(self);
}

uint16_t whiteout_m2_M2Material_get_flags(const whiteout_M2Material* self) {
    return reinterpret_cast<const whiteout::m2::Material*>(self)->flags;
}

void whiteout_m2_M2Material_set_flags(whiteout_M2Material* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Material*>(self)->flags = value;
}

uint16_t whiteout_m2_M2Material_get_blendingMode(const whiteout_M2Material* self) {
    return reinterpret_cast<const whiteout::m2::Material*>(self)->blendingMode;
}

void whiteout_m2_M2Material_set_blendingMode(whiteout_M2Material* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Material*>(self)->blendingMode = value;
}

} // extern "C"

// ── M2TextureWeight ─────────────────────────────────────────────────

extern "C" {

whiteout_M2TextureWeight* whiteout_m2_M2TextureWeight_new(void) {
    return reinterpret_cast<whiteout_M2TextureWeight*>(new whiteout::m2::TextureWeight());
}

void whiteout_m2_M2TextureWeight_delete(whiteout_M2TextureWeight* self) {
    delete reinterpret_cast<whiteout::m2::TextureWeight*>(self);
}

whiteout_M2AnimationTrackI16* whiteout_m2_M2TextureWeight_get_weight(whiteout_M2TextureWeight* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackI16*>(&reinterpret_cast<whiteout::m2::TextureWeight*>(self)->weight);
}

void whiteout_m2_M2TextureWeight_set_weight(whiteout_M2TextureWeight* self, const whiteout_M2AnimationTrackI16* value) {
    reinterpret_cast<whiteout::m2::TextureWeight*>(self)->weight = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(value);
}

} // extern "C"

// ── M2TextureTransform ─────────────────────────────────────────────────

extern "C" {

whiteout_M2TextureTransform* whiteout_m2_M2TextureTransform_new(void) {
    return reinterpret_cast<whiteout_M2TextureTransform*>(new whiteout::m2::TextureTransform());
}

void whiteout_m2_M2TextureTransform_delete(whiteout_M2TextureTransform* self) {
    delete reinterpret_cast<whiteout::m2::TextureTransform*>(self);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2TextureTransform_get_translation(whiteout_M2TextureTransform* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::TextureTransform*>(self)->translation);
}

void whiteout_m2_M2TextureTransform_set_translation(whiteout_M2TextureTransform* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::TextureTransform*>(self)->translation = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackM2CompatQuaternion* whiteout_m2_M2TextureTransform_get_rotation(whiteout_M2TextureTransform* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CompatQuaternion*>(&reinterpret_cast<whiteout::m2::TextureTransform*>(self)->rotation);
}

void whiteout_m2_M2TextureTransform_set_rotation(whiteout_M2TextureTransform* self, const whiteout_M2AnimationTrackM2CompatQuaternion* value) {
    reinterpret_cast<whiteout::m2::TextureTransform*>(self)->rotation = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(value);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2TextureTransform_get_scaling(whiteout_M2TextureTransform* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::TextureTransform*>(self)->scaling);
}

void whiteout_m2_M2TextureTransform_set_scaling(whiteout_M2TextureTransform* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::TextureTransform*>(self)->scaling = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

} // extern "C"

// ── M2ColorAnimation ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ColorAnimation* whiteout_m2_M2ColorAnimation_new(void) {
    return reinterpret_cast<whiteout_M2ColorAnimation*>(new whiteout::m2::ColorAnimation());
}

void whiteout_m2_M2ColorAnimation_delete(whiteout_M2ColorAnimation* self) {
    delete reinterpret_cast<whiteout::m2::ColorAnimation*>(self);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2ColorAnimation_get_color(whiteout_M2ColorAnimation* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::ColorAnimation*>(self)->color);
}

void whiteout_m2_M2ColorAnimation_set_color(whiteout_M2ColorAnimation* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::ColorAnimation*>(self)->color = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackI16* whiteout_m2_M2ColorAnimation_get_alpha(whiteout_M2ColorAnimation* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackI16*>(&reinterpret_cast<whiteout::m2::ColorAnimation*>(self)->alpha);
}

void whiteout_m2_M2ColorAnimation_set_alpha(whiteout_M2ColorAnimation* self, const whiteout_M2AnimationTrackI16* value) {
    reinterpret_cast<whiteout::m2::ColorAnimation*>(self)->alpha = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(value);
}

} // extern "C"

// ── M2Light ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Light* whiteout_m2_M2Light_new(void) {
    return reinterpret_cast<whiteout_M2Light*>(new whiteout::m2::Light());
}

void whiteout_m2_M2Light_delete(whiteout_M2Light* self) {
    delete reinterpret_cast<whiteout::m2::Light*>(self);
}

uint16_t whiteout_m2_M2Light_get_type(const whiteout_M2Light* self) {
    return reinterpret_cast<const whiteout::m2::Light*>(self)->type;
}

void whiteout_m2_M2Light_set_type(whiteout_M2Light* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->type = value;
}

int16_t whiteout_m2_M2Light_get_boneId(const whiteout_M2Light* self) {
    return reinterpret_cast<const whiteout::m2::Light*>(self)->boneId;
}

void whiteout_m2_M2Light_set_boneId(whiteout_M2Light* self, int16_t value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->boneId = value;
}

whiteout_Vector3f* whiteout_m2_M2Light_get_position(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Light*>(self)->position);
}

void whiteout_m2_M2Light_set_position(whiteout_M2Light* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2Light_get_ambientColor(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::Light*>(self)->ambientColor);
}

void whiteout_m2_M2Light_set_ambientColor(whiteout_M2Light* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->ambientColor = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Light_get_ambientIntensity(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Light*>(self)->ambientIntensity);
}

void whiteout_m2_M2Light_set_ambientIntensity(whiteout_M2Light* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->ambientIntensity = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2Light_get_diffuseColor(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::Light*>(self)->diffuseColor);
}

void whiteout_m2_M2Light_set_diffuseColor(whiteout_M2Light* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->diffuseColor = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Light_get_diffuseIntensity(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Light*>(self)->diffuseIntensity);
}

void whiteout_m2_M2Light_set_diffuseIntensity(whiteout_M2Light* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->diffuseIntensity = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Light_get_attenuationStart(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Light*>(self)->attenuationStart);
}

void whiteout_m2_M2Light_set_attenuationStart(whiteout_M2Light* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->attenuationStart = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Light_get_attenuationEnd(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Light*>(self)->attenuationEnd);
}

void whiteout_m2_M2Light_set_attenuationEnd(whiteout_M2Light* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->attenuationEnd = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackU8* whiteout_m2_M2Light_get_visibility(whiteout_M2Light* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackU8*>(&reinterpret_cast<whiteout::m2::Light*>(self)->visibility);
}

void whiteout_m2_M2Light_set_visibility(whiteout_M2Light* self, const whiteout_M2AnimationTrackU8* value) {
    reinterpret_cast<whiteout::m2::Light*>(self)->visibility = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(value);
}

} // extern "C"

// ── M2CameraSpline ─────────────────────────────────────────────────

extern "C" {

whiteout_M2CameraSpline* whiteout_m2_M2CameraSpline_new(void) {
    return reinterpret_cast<whiteout_M2CameraSpline*>(new whiteout::m2::CameraSpline());
}

void whiteout_m2_M2CameraSpline_delete(whiteout_M2CameraSpline* self) {
    delete reinterpret_cast<whiteout::m2::CameraSpline*>(self);
}

whiteout_Vector3f* whiteout_m2_M2CameraSpline_get_value(whiteout_M2CameraSpline* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::CameraSpline*>(self)->value);
}

void whiteout_m2_M2CameraSpline_set_value(whiteout_M2CameraSpline* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::CameraSpline*>(self)->value = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_m2_M2CameraSpline_get_inTangent(whiteout_M2CameraSpline* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::CameraSpline*>(self)->inTangent);
}

void whiteout_m2_M2CameraSpline_set_inTangent(whiteout_M2CameraSpline* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::CameraSpline*>(self)->inTangent = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_m2_M2CameraSpline_get_outTangent(whiteout_M2CameraSpline* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::CameraSpline*>(self)->outTangent);
}

void whiteout_m2_M2CameraSpline_set_outTangent(whiteout_M2CameraSpline* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::CameraSpline*>(self)->outTangent = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

} // extern "C"

// ── M2Camera ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Camera* whiteout_m2_M2Camera_new(void) {
    return reinterpret_cast<whiteout_M2Camera*>(new whiteout::m2::Camera());
}

void whiteout_m2_M2Camera_delete(whiteout_M2Camera* self) {
    delete reinterpret_cast<whiteout::m2::Camera*>(self);
}

uint32_t whiteout_m2_M2Camera_get_type(const whiteout_M2Camera* self) {
    return reinterpret_cast<const whiteout::m2::Camera*>(self)->type;
}

void whiteout_m2_M2Camera_set_type(whiteout_M2Camera* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->type = value;
}

float whiteout_m2_M2Camera_get_fieldOfView(const whiteout_M2Camera* self) {
    return reinterpret_cast<const whiteout::m2::Camera*>(self)->fieldOfView;
}

void whiteout_m2_M2Camera_set_fieldOfView(whiteout_M2Camera* self, float value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->fieldOfView = value;
}

float whiteout_m2_M2Camera_get_farClip(const whiteout_M2Camera* self) {
    return reinterpret_cast<const whiteout::m2::Camera*>(self)->farClip;
}

void whiteout_m2_M2Camera_set_farClip(whiteout_M2Camera* self, float value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->farClip = value;
}

float whiteout_m2_M2Camera_get_nearClip(const whiteout_M2Camera* self) {
    return reinterpret_cast<const whiteout::m2::Camera*>(self)->nearClip;
}

void whiteout_m2_M2Camera_set_nearClip(whiteout_M2Camera* self, float value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->nearClip = value;
}

whiteout_M2AnimationTrackM2CameraSpline* whiteout_m2_M2Camera_get_positions(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CameraSpline*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->positions);
}

void whiteout_m2_M2Camera_set_positions(whiteout_M2Camera* self, const whiteout_M2AnimationTrackM2CameraSpline* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->positions = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(value);
}

whiteout_Vector3f* whiteout_m2_M2Camera_get_positionBase(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->positionBase);
}

void whiteout_m2_M2Camera_set_positionBase(whiteout_M2Camera* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->positionBase = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_M2AnimationTrackM2CameraSpline* whiteout_m2_M2Camera_get_targetPositions(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CameraSpline*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->targetPositions);
}

void whiteout_m2_M2Camera_set_targetPositions(whiteout_M2Camera* self, const whiteout_M2AnimationTrackM2CameraSpline* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->targetPositions = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(value);
}

whiteout_Vector3f* whiteout_m2_M2Camera_get_targetPositionBase(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->targetPositionBase);
}

void whiteout_m2_M2Camera_set_targetPositionBase(whiteout_M2Camera* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->targetPositionBase = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Camera_get_roll(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->roll);
}

void whiteout_m2_M2Camera_set_roll(whiteout_M2Camera* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->roll = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2Camera_get_fieldOfViewTrack(whiteout_M2Camera* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::Camera*>(self)->fieldOfViewTrack);
}

void whiteout_m2_M2Camera_set_fieldOfViewTrack(whiteout_M2Camera* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::Camera*>(self)->fieldOfViewTrack = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

} // extern "C"

// ── M2Attachment ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Attachment* whiteout_m2_M2Attachment_new(void) {
    return reinterpret_cast<whiteout_M2Attachment*>(new whiteout::m2::Attachment());
}

void whiteout_m2_M2Attachment_delete(whiteout_M2Attachment* self) {
    delete reinterpret_cast<whiteout::m2::Attachment*>(self);
}

uint32_t whiteout_m2_M2Attachment_get_id(const whiteout_M2Attachment* self) {
    return reinterpret_cast<const whiteout::m2::Attachment*>(self)->id;
}

void whiteout_m2_M2Attachment_set_id(whiteout_M2Attachment* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Attachment*>(self)->id = value;
}

uint16_t whiteout_m2_M2Attachment_get_boneId(const whiteout_M2Attachment* self) {
    return reinterpret_cast<const whiteout::m2::Attachment*>(self)->boneId;
}

void whiteout_m2_M2Attachment_set_boneId(whiteout_M2Attachment* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Attachment*>(self)->boneId = value;
}

uint16_t whiteout_m2_M2Attachment_get_unknown(const whiteout_M2Attachment* self) {
    return reinterpret_cast<const whiteout::m2::Attachment*>(self)->unknown;
}

void whiteout_m2_M2Attachment_set_unknown(whiteout_M2Attachment* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::Attachment*>(self)->unknown = value;
}

whiteout_Vector3f* whiteout_m2_M2Attachment_get_position(whiteout_M2Attachment* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Attachment*>(self)->position);
}

void whiteout_m2_M2Attachment_set_position(whiteout_M2Attachment* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Attachment*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_M2AnimationTrackU8* whiteout_m2_M2Attachment_get_animate(whiteout_M2Attachment* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackU8*>(&reinterpret_cast<whiteout::m2::Attachment*>(self)->animate);
}

void whiteout_m2_M2Attachment_set_animate(whiteout_M2Attachment* self, const whiteout_M2AnimationTrackU8* value) {
    reinterpret_cast<whiteout::m2::Attachment*>(self)->animate = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(value);
}

} // extern "C"

// ── M2RibbonEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_M2RibbonEmitter* whiteout_m2_M2RibbonEmitter_new(void) {
    return reinterpret_cast<whiteout_M2RibbonEmitter*>(new whiteout::m2::RibbonEmitter());
}

void whiteout_m2_M2RibbonEmitter_delete(whiteout_M2RibbonEmitter* self) {
    delete reinterpret_cast<whiteout::m2::RibbonEmitter*>(self);
}

uint32_t whiteout_m2_M2RibbonEmitter_get_ribbonId(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->ribbonId;
}

void whiteout_m2_M2RibbonEmitter_set_ribbonId(whiteout_M2RibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->ribbonId = value;
}

uint32_t whiteout_m2_M2RibbonEmitter_get_boneId(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->boneId;
}

void whiteout_m2_M2RibbonEmitter_set_boneId(whiteout_M2RibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->boneId = value;
}

whiteout_Vector3f* whiteout_m2_M2RibbonEmitter_get_position(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->position);
}

void whiteout_m2_M2RibbonEmitter_set_position(whiteout_M2RibbonEmitter* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

size_t whiteout_m2_M2RibbonEmitter_get_textureIndices_count(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->textureIndices.size();
}

void whiteout_m2_M2RibbonEmitter_resize_textureIndices(whiteout_M2RibbonEmitter* self, size_t count) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->textureIndices.resize(count);
}

const uint16_t* whiteout_m2_M2RibbonEmitter_get_textureIndices_data(const whiteout_M2RibbonEmitter* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->textureIndices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2RibbonEmitter_assign_textureIndices(whiteout_M2RibbonEmitter* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->textureIndices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2RibbonEmitter_get_materialIndices_count(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->materialIndices.size();
}

void whiteout_m2_M2RibbonEmitter_resize_materialIndices(whiteout_M2RibbonEmitter* self, size_t count) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->materialIndices.resize(count);
}

const uint16_t* whiteout_m2_M2RibbonEmitter_get_materialIndices_data(const whiteout_M2RibbonEmitter* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->materialIndices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2RibbonEmitter_assign_materialIndices(whiteout_M2RibbonEmitter* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->materialIndices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2RibbonEmitter_get_colorTrack(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->colorTrack);
}

void whiteout_m2_M2RibbonEmitter_set_colorTrack(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->colorTrack = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2AnimationTrackI16* whiteout_m2_M2RibbonEmitter_get_alphaTrack(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackI16*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->alphaTrack);
}

void whiteout_m2_M2RibbonEmitter_set_alphaTrack(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackI16* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->alphaTrack = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2RibbonEmitter_get_heightAbove(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->heightAbove);
}

void whiteout_m2_M2RibbonEmitter_set_heightAbove(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->heightAbove = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2RibbonEmitter_get_heightBelow(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->heightBelow);
}

void whiteout_m2_M2RibbonEmitter_set_heightBelow(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->heightBelow = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

float whiteout_m2_M2RibbonEmitter_get_edgesPerSecond(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->edgesPerSecond;
}

void whiteout_m2_M2RibbonEmitter_set_edgesPerSecond(whiteout_M2RibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->edgesPerSecond = value;
}

float whiteout_m2_M2RibbonEmitter_get_edgeLifetime(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->edgeLifetime;
}

void whiteout_m2_M2RibbonEmitter_set_edgeLifetime(whiteout_M2RibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->edgeLifetime = value;
}

float whiteout_m2_M2RibbonEmitter_get_gravity(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->gravity;
}

void whiteout_m2_M2RibbonEmitter_set_gravity(whiteout_M2RibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->gravity = value;
}

uint16_t whiteout_m2_M2RibbonEmitter_get_textureRows(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->textureRows;
}

void whiteout_m2_M2RibbonEmitter_set_textureRows(whiteout_M2RibbonEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->textureRows = value;
}

uint16_t whiteout_m2_M2RibbonEmitter_get_textureCols(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->textureCols;
}

void whiteout_m2_M2RibbonEmitter_set_textureCols(whiteout_M2RibbonEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->textureCols = value;
}

whiteout_M2AnimationTrackU16* whiteout_m2_M2RibbonEmitter_get_texSlot(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackU16*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->texSlot);
}

void whiteout_m2_M2RibbonEmitter_set_texSlot(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackU16* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->texSlot = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(value);
}

whiteout_M2AnimationTrackU8* whiteout_m2_M2RibbonEmitter_get_visibility(whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackU8*>(&reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->visibility);
}

void whiteout_m2_M2RibbonEmitter_set_visibility(whiteout_M2RibbonEmitter* self, const whiteout_M2AnimationTrackU8* value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->visibility = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(value);
}

int16_t whiteout_m2_M2RibbonEmitter_get_priorityPlane(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->priorityPlane;
}

void whiteout_m2_M2RibbonEmitter_set_priorityPlane(whiteout_M2RibbonEmitter* self, int16_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->priorityPlane = value;
}

int8_t whiteout_m2_M2RibbonEmitter_get_ribbonColorIndex(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->ribbonColorIndex;
}

void whiteout_m2_M2RibbonEmitter_set_ribbonColorIndex(whiteout_M2RibbonEmitter* self, int8_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->ribbonColorIndex = value;
}

int8_t whiteout_m2_M2RibbonEmitter_get_textureTransformIndex(const whiteout_M2RibbonEmitter* self) {
    return reinterpret_cast<const whiteout::m2::RibbonEmitter*>(self)->textureTransformIndex;
}

void whiteout_m2_M2RibbonEmitter_set_textureTransformIndex(whiteout_M2RibbonEmitter* self, int8_t value) {
    reinterpret_cast<whiteout::m2::RibbonEmitter*>(self)->textureTransformIndex = value;
}

} // extern "C"

// ── M2Box ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Box* whiteout_m2_M2Box_new(void) {
    return reinterpret_cast<whiteout_M2Box*>(new whiteout::m2::M2Box());
}

void whiteout_m2_M2Box_delete(whiteout_M2Box* self) {
    delete reinterpret_cast<whiteout::m2::M2Box*>(self);
}

whiteout_Vector3f* whiteout_m2_M2Box_get_minimum(whiteout_M2Box* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::M2Box*>(self)->minimum);
}

void whiteout_m2_M2Box_set_minimum(whiteout_M2Box* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::M2Box*>(self)->minimum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_m2_M2Box_get_maximum(whiteout_M2Box* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::M2Box*>(self)->maximum);
}

void whiteout_m2_M2Box_set_maximum(whiteout_M2Box* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::M2Box*>(self)->maximum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

} // extern "C"

// ── M2ParticleEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ParticleEmitter* whiteout_m2_M2ParticleEmitter_new(void) {
    return reinterpret_cast<whiteout_M2ParticleEmitter*>(new whiteout::m2::ParticleEmitter());
}

void whiteout_m2_M2ParticleEmitter_delete(whiteout_M2ParticleEmitter* self) {
    delete reinterpret_cast<whiteout::m2::ParticleEmitter*>(self);
}

uint32_t whiteout_m2_M2ParticleEmitter_get_particleId(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->particleId;
}

void whiteout_m2_M2ParticleEmitter_set_particleId(whiteout_M2ParticleEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->particleId = value;
}

int32_t whiteout_m2_M2ParticleEmitter_get_flags(const whiteout_M2ParticleEmitter* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->flags);
}

void whiteout_m2_M2ParticleEmitter_set_flags(whiteout_M2ParticleEmitter* self, int32_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->flags = static_cast<whiteout::m2::ParticleFlag>(value);
}

whiteout_Vector3f* whiteout_m2_M2ParticleEmitter_get_position(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->position);
}

void whiteout_m2_M2ParticleEmitter_set_position(whiteout_M2ParticleEmitter* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

uint16_t whiteout_m2_M2ParticleEmitter_get_boneId(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->boneId;
}

void whiteout_m2_M2ParticleEmitter_set_boneId(whiteout_M2ParticleEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->boneId = value;
}

whiteout_CString whiteout_m2_M2ParticleEmitter_get_particleModelFilename(const whiteout_M2ParticleEmitter* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->particleModelFilename);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_m2_M2ParticleEmitter_set_particleModelFilename(whiteout_M2ParticleEmitter* self, const char* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->particleModelFilename = (value ? value : "");
}

whiteout_CString whiteout_m2_M2ParticleEmitter_get_childEmittersModelFilename(const whiteout_M2ParticleEmitter* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->childEmittersModelFilename);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_m2_M2ParticleEmitter_set_childEmittersModelFilename(whiteout_M2ParticleEmitter* self, const char* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->childEmittersModelFilename = (value ? value : "");
}

int32_t whiteout_m2_M2ParticleEmitter_get_blendingType(const whiteout_M2ParticleEmitter* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->blendingType);
}

void whiteout_m2_M2ParticleEmitter_set_blendingType(whiteout_M2ParticleEmitter* self, int32_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->blendingType = static_cast<whiteout::m2::ParticleBlending>(value);
}

int32_t whiteout_m2_M2ParticleEmitter_get_emitterType(const whiteout_M2ParticleEmitter* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->emitterType);
}

void whiteout_m2_M2ParticleEmitter_set_emitterType(whiteout_M2ParticleEmitter* self, int32_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emitterType = static_cast<whiteout::m2::ParticleEmitterType>(value);
}

uint16_t whiteout_m2_M2ParticleEmitter_get_particleColorIndex(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->particleColorIndex;
}

void whiteout_m2_M2ParticleEmitter_set_particleColorIndex(whiteout_M2ParticleEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->particleColorIndex = value;
}

int16_t whiteout_m2_M2ParticleEmitter_get_textureTilerotation(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->textureTilerotation;
}

void whiteout_m2_M2ParticleEmitter_set_textureTilerotation(whiteout_M2ParticleEmitter* self, int16_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->textureTilerotation = value;
}

uint16_t whiteout_m2_M2ParticleEmitter_get_rows(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->rows;
}

void whiteout_m2_M2ParticleEmitter_set_rows(whiteout_M2ParticleEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->rows = value;
}

uint16_t whiteout_m2_M2ParticleEmitter_get_columns(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->columns;
}

void whiteout_m2_M2ParticleEmitter_set_columns(whiteout_M2ParticleEmitter* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->columns = value;
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_emissionSpeed(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionSpeed);
}

void whiteout_m2_M2ParticleEmitter_set_emissionSpeed(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionSpeed = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_speedVariation(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->speedVariation);
}

void whiteout_m2_M2ParticleEmitter_set_speedVariation(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->speedVariation = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_verticalRange(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->verticalRange);
}

void whiteout_m2_M2ParticleEmitter_set_verticalRange(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->verticalRange = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_horizontalRange(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->horizontalRange);
}

void whiteout_m2_M2ParticleEmitter_set_horizontalRange(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->horizontalRange = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_gravity(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->gravity);
}

void whiteout_m2_M2ParticleEmitter_set_gravity(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->gravity = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_lifespan(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->lifespan);
}

void whiteout_m2_M2ParticleEmitter_set_lifespan(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->lifespan = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

float whiteout_m2_M2ParticleEmitter_get_lifespanVariation(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->lifespanVariation;
}

void whiteout_m2_M2ParticleEmitter_set_lifespanVariation(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->lifespanVariation = value;
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_emissionRate(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionRate);
}

void whiteout_m2_M2ParticleEmitter_set_emissionRate(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionRate = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

float whiteout_m2_M2ParticleEmitter_get_emissionRateVariation(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->emissionRateVariation;
}

void whiteout_m2_M2ParticleEmitter_set_emissionRateVariation(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionRateVariation = value;
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_emissionAreaWidth(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionAreaWidth);
}

void whiteout_m2_M2ParticleEmitter_set_emissionAreaWidth(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionAreaWidth = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_emissionAreaLength(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionAreaLength);
}

void whiteout_m2_M2ParticleEmitter_set_emissionAreaLength(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->emissionAreaLength = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2AnimationTrackF32* whiteout_m2_M2ParticleEmitter_get_zSource(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->zSource);
}

void whiteout_m2_M2ParticleEmitter_set_zSource(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackF32* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->zSource = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(value);
}

whiteout_M2ParticleAnimationTrackVector3f* whiteout_m2_M2ParticleEmitter_get_colorTrack(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2ParticleAnimationTrackVector3f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->colorTrack);
}

void whiteout_m2_M2ParticleEmitter_set_colorTrack(whiteout_M2ParticleEmitter* self, const whiteout_M2ParticleAnimationTrackVector3f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->colorTrack = *reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(value);
}

whiteout_M2ParticleAnimationTrackVector2f* whiteout_m2_M2ParticleEmitter_get_scaleTrack(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2ParticleAnimationTrackVector2f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->scaleTrack);
}

void whiteout_m2_M2ParticleEmitter_set_scaleTrack(whiteout_M2ParticleEmitter* self, const whiteout_M2ParticleAnimationTrackVector2f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->scaleTrack = *reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(value);
}

whiteout_Vector2f* whiteout_m2_M2ParticleEmitter_get_scaleVary(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_Vector2f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->scaleVary);
}

void whiteout_m2_M2ParticleEmitter_set_scaleVary(whiteout_M2ParticleEmitter* self, const whiteout_Vector2f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->scaleVary = *reinterpret_cast<const whiteout::Vector2f*>(value);
}

float whiteout_m2_M2ParticleEmitter_get_tailLength(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->tailLength;
}

void whiteout_m2_M2ParticleEmitter_set_tailLength(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->tailLength = value;
}

float whiteout_m2_M2ParticleEmitter_get_twinkleSpeed(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->twinkleSpeed;
}

void whiteout_m2_M2ParticleEmitter_set_twinkleSpeed(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->twinkleSpeed = value;
}

float whiteout_m2_M2ParticleEmitter_get_twinklePercent(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->twinklePercent;
}

void whiteout_m2_M2ParticleEmitter_set_twinklePercent(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->twinklePercent = value;
}

whiteout_Vector2f* whiteout_m2_M2ParticleEmitter_get_twinkleScale(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_Vector2f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->twinkleScale);
}

void whiteout_m2_M2ParticleEmitter_set_twinkleScale(whiteout_M2ParticleEmitter* self, const whiteout_Vector2f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->twinkleScale = *reinterpret_cast<const whiteout::Vector2f*>(value);
}

float whiteout_m2_M2ParticleEmitter_get_inheritVelocityScale(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->inheritVelocityScale;
}

void whiteout_m2_M2ParticleEmitter_set_inheritVelocityScale(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->inheritVelocityScale = value;
}

float whiteout_m2_M2ParticleEmitter_get_drag(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->drag;
}

void whiteout_m2_M2ParticleEmitter_set_drag(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->drag = value;
}

float whiteout_m2_M2ParticleEmitter_get_baseSpin(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->baseSpin;
}

void whiteout_m2_M2ParticleEmitter_set_baseSpin(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->baseSpin = value;
}

float whiteout_m2_M2ParticleEmitter_get_baseSpinVariation(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->baseSpinVariation;
}

void whiteout_m2_M2ParticleEmitter_set_baseSpinVariation(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->baseSpinVariation = value;
}

float whiteout_m2_M2ParticleEmitter_get_spinSpeed(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->spinSpeed;
}

void whiteout_m2_M2ParticleEmitter_set_spinSpeed(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->spinSpeed = value;
}

float whiteout_m2_M2ParticleEmitter_get_spinSpeedVariation(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->spinSpeedVariation;
}

void whiteout_m2_M2ParticleEmitter_set_spinSpeedVariation(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->spinSpeedVariation = value;
}

whiteout_M2Box* whiteout_m2_M2ParticleEmitter_get_tumble(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2Box*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->tumble);
}

void whiteout_m2_M2ParticleEmitter_set_tumble(whiteout_M2ParticleEmitter* self, const whiteout_M2Box* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->tumble = *reinterpret_cast<const whiteout::m2::M2Box*>(value);
}

whiteout_Vector3f* whiteout_m2_M2ParticleEmitter_get_windVector(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->windVector);
}

void whiteout_m2_M2ParticleEmitter_set_windVector(whiteout_M2ParticleEmitter* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->windVector = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_m2_M2ParticleEmitter_get_windTime(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->windTime;
}

void whiteout_m2_M2ParticleEmitter_set_windTime(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->windTime = value;
}

float whiteout_m2_M2ParticleEmitter_get_followSpeed1(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->followSpeed1;
}

void whiteout_m2_M2ParticleEmitter_set_followSpeed1(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->followSpeed1 = value;
}

float whiteout_m2_M2ParticleEmitter_get_followScale1(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->followScale1;
}

void whiteout_m2_M2ParticleEmitter_set_followScale1(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->followScale1 = value;
}

float whiteout_m2_M2ParticleEmitter_get_followSpeed2(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->followSpeed2;
}

void whiteout_m2_M2ParticleEmitter_set_followSpeed2(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->followSpeed2 = value;
}

float whiteout_m2_M2ParticleEmitter_get_followScale2(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->followScale2;
}

void whiteout_m2_M2ParticleEmitter_set_followScale2(whiteout_M2ParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->followScale2 = value;
}

size_t whiteout_m2_M2ParticleEmitter_get_splinePoints_count(const whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->splinePoints.size();
}

void whiteout_m2_M2ParticleEmitter_resize_splinePoints(whiteout_M2ParticleEmitter* self, size_t count) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->splinePoints.resize(count);
}

const float* whiteout_m2_M2ParticleEmitter_get_splinePoints_data(const whiteout_M2ParticleEmitter* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::ParticleEmitter*>(self)->splinePoints;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2ParticleEmitter_assign_splinePoints(whiteout_M2ParticleEmitter* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->splinePoints;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

whiteout_M2AnimationTrackU8* whiteout_m2_M2ParticleEmitter_get_enabledIn(whiteout_M2ParticleEmitter* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackU8*>(&reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->enabledIn);
}

void whiteout_m2_M2ParticleEmitter_set_enabledIn(whiteout_M2ParticleEmitter* self, const whiteout_M2AnimationTrackU8* value) {
    reinterpret_cast<whiteout::m2::ParticleEmitter*>(self)->enabledIn = *reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(value);
}

} // extern "C"

// ── M2Event ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Event* whiteout_m2_M2Event_new(void) {
    return reinterpret_cast<whiteout_M2Event*>(new whiteout::m2::Event());
}

void whiteout_m2_M2Event_delete(whiteout_M2Event* self) {
    delete reinterpret_cast<whiteout::m2::Event*>(self);
}

uint32_t whiteout_m2_M2Event_get_identifier(const whiteout_M2Event* self) {
    return reinterpret_cast<const whiteout::m2::Event*>(self)->identifier;
}

void whiteout_m2_M2Event_set_identifier(whiteout_M2Event* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Event*>(self)->identifier = value;
}

uint32_t whiteout_m2_M2Event_get_data(const whiteout_M2Event* self) {
    return reinterpret_cast<const whiteout::m2::Event*>(self)->data;
}

void whiteout_m2_M2Event_set_data(whiteout_M2Event* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Event*>(self)->data = value;
}

uint32_t whiteout_m2_M2Event_get_boneId(const whiteout_M2Event* self) {
    return reinterpret_cast<const whiteout::m2::Event*>(self)->boneId;
}

void whiteout_m2_M2Event_set_boneId(whiteout_M2Event* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Event*>(self)->boneId = value;
}

whiteout_Vector3f* whiteout_m2_M2Event_get_position(whiteout_M2Event* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::m2::Event*>(self)->position);
}

void whiteout_m2_M2Event_set_position(whiteout_M2Event* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::m2::Event*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_M2AnimationTrackBase* whiteout_m2_M2Event_get_enabled(whiteout_M2Event* self) {
    return reinterpret_cast<whiteout_M2AnimationTrackBase*>(&reinterpret_cast<whiteout::m2::Event*>(self)->enabled);
}

void whiteout_m2_M2Event_set_enabled(whiteout_M2Event* self, const whiteout_M2AnimationTrackBase* value) {
    reinterpret_cast<whiteout::m2::Event*>(self)->enabled = *reinterpret_cast<const whiteout::m2::AnimationTrackBase*>(value);
}

} // extern "C"

// ── M2Model ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Model* whiteout_m2_M2Model_new(void) {
    return reinterpret_cast<whiteout_M2Model*>(new whiteout::m2::Model());
}

void whiteout_m2_M2Model_delete(whiteout_M2Model* self) {
    delete reinterpret_cast<whiteout::m2::Model*>(self);
}

whiteout_CString whiteout_m2_M2Model_get_modelName(const whiteout_M2Model* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::m2::Model*>(self)->modelName);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_m2_M2Model_set_modelName(whiteout_M2Model* self, const char* value) {
    reinterpret_cast<whiteout::m2::Model*>(self)->modelName = (value ? value : "");
}

whiteout_M2GlobalFlags* whiteout_m2_M2Model_get_globalFlags(whiteout_M2Model* self) {
    return reinterpret_cast<whiteout_M2GlobalFlags*>(&reinterpret_cast<whiteout::m2::Model*>(self)->globalFlags);
}

void whiteout_m2_M2Model_set_globalFlags(whiteout_M2Model* self, const whiteout_M2GlobalFlags* value) {
    reinterpret_cast<whiteout::m2::Model*>(self)->globalFlags = *reinterpret_cast<const whiteout::m2::GlobalFlags*>(value);
}

size_t whiteout_m2_M2Model_get_globalLoops_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->globalLoops.size();
}

void whiteout_m2_M2Model_resize_globalLoops(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->globalLoops.resize(count);
}

whiteout_M2GlobalSequence* whiteout_m2_M2Model_get_globalLoops_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2GlobalSequence*>(&reinterpret_cast<whiteout::m2::Model*>(self)->globalLoops[index]);
}

size_t whiteout_m2_M2Model_get_sequences_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->sequences.size();
}

void whiteout_m2_M2Model_resize_sequences(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->sequences.resize(count);
}

whiteout_M2Sequence* whiteout_m2_M2Model_get_sequences_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Sequence*>(&reinterpret_cast<whiteout::m2::Model*>(self)->sequences[index]);
}

size_t whiteout_m2_M2Model_get_sequenceIdxHashById_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->sequenceIdxHashById.size();
}

void whiteout_m2_M2Model_resize_sequenceIdxHashById(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->sequenceIdxHashById.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_sequenceIdxHashById_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->sequenceIdxHashById;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_sequenceIdxHashById(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->sequenceIdxHashById;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_bones_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->bones.size();
}

void whiteout_m2_M2Model_resize_bones(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->bones.resize(count);
}

whiteout_M2Bone* whiteout_m2_M2Model_get_bones_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Bone*>(&reinterpret_cast<whiteout::m2::Model*>(self)->bones[index]);
}

size_t whiteout_m2_M2Model_get_keyBoneIds_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->keyBoneIds.size();
}

void whiteout_m2_M2Model_resize_keyBoneIds(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->keyBoneIds.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_keyBoneIds_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->keyBoneIds;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_keyBoneIds(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->keyBoneIds;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_vertices_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->vertices.size();
}

void whiteout_m2_M2Model_resize_vertices(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->vertices.resize(count);
}

whiteout_M2Vertex* whiteout_m2_M2Model_get_vertices_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Vertex*>(&reinterpret_cast<whiteout::m2::Model*>(self)->vertices[index]);
}

size_t whiteout_m2_M2Model_get_skinProfiles_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->skinProfiles.size();
}

void whiteout_m2_M2Model_resize_skinProfiles(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->skinProfiles.resize(count);
}

whiteout_M2SkinProfile* whiteout_m2_M2Model_get_skinProfiles_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2SkinProfile*>(&reinterpret_cast<whiteout::m2::Model*>(self)->skinProfiles[index]);
}

size_t whiteout_m2_M2Model_get_lodProfiles_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->lodProfiles.size();
}

void whiteout_m2_M2Model_resize_lodProfiles(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->lodProfiles.resize(count);
}

whiteout_M2SkinProfile* whiteout_m2_M2Model_get_lodProfiles_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2SkinProfile*>(&reinterpret_cast<whiteout::m2::Model*>(self)->lodProfiles[index]);
}

uint32_t whiteout_m2_M2Model_get_numSkinProfiles(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->numSkinProfiles;
}

void whiteout_m2_M2Model_set_numSkinProfiles(whiteout_M2Model* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::Model*>(self)->numSkinProfiles = value;
}

size_t whiteout_m2_M2Model_get_colors_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->colors.size();
}

void whiteout_m2_M2Model_resize_colors(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->colors.resize(count);
}

whiteout_M2ColorAnimation* whiteout_m2_M2Model_get_colors_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2ColorAnimation*>(&reinterpret_cast<whiteout::m2::Model*>(self)->colors[index]);
}

size_t whiteout_m2_M2Model_get_textures_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textures.size();
}

void whiteout_m2_M2Model_resize_textures(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textures.resize(count);
}

whiteout_M2Texture* whiteout_m2_M2Model_get_textures_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Texture*>(&reinterpret_cast<whiteout::m2::Model*>(self)->textures[index]);
}

size_t whiteout_m2_M2Model_get_textureWeights_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureWeights.size();
}

void whiteout_m2_M2Model_resize_textureWeights(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureWeights.resize(count);
}

whiteout_M2TextureWeight* whiteout_m2_M2Model_get_textureWeights_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2TextureWeight*>(&reinterpret_cast<whiteout::m2::Model*>(self)->textureWeights[index]);
}

size_t whiteout_m2_M2Model_get_textureTransforms_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureTransforms.size();
}

void whiteout_m2_M2Model_resize_textureTransforms(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureTransforms.resize(count);
}

whiteout_M2TextureTransform* whiteout_m2_M2Model_get_textureTransforms_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2TextureTransform*>(&reinterpret_cast<whiteout::m2::Model*>(self)->textureTransforms[index]);
}

size_t whiteout_m2_M2Model_get_textureIndicesById_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureIndicesById.size();
}

void whiteout_m2_M2Model_resize_textureIndicesById(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureIndicesById.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureIndicesById_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureIndicesById;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureIndicesById(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureIndicesById;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_materials_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->materials.size();
}

void whiteout_m2_M2Model_resize_materials(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->materials.resize(count);
}

whiteout_M2Material* whiteout_m2_M2Model_get_materials_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Material*>(&reinterpret_cast<whiteout::m2::Model*>(self)->materials[index]);
}

size_t whiteout_m2_M2Model_get_boneCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->boneCombos.size();
}

void whiteout_m2_M2Model_resize_boneCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->boneCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_boneCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->boneCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_boneCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->boneCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_textureCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureCombos.size();
}

void whiteout_m2_M2Model_resize_textureCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_textureCoordCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureCoordCombos.size();
}

void whiteout_m2_M2Model_resize_textureCoordCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureCoordCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureCoordCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureCoordCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureCoordCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureCoordCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_textureWeightCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureWeightCombos.size();
}

void whiteout_m2_M2Model_resize_textureWeightCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureWeightCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureWeightCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureWeightCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureWeightCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureWeightCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_textureTransformCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureTransformCombos.size();
}

void whiteout_m2_M2Model_resize_textureTransformCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureTransformCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureTransformCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureTransformCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureTransformCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureTransformCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

whiteout_M2Extent* whiteout_m2_M2Model_get_bounding(whiteout_M2Model* self) {
    return reinterpret_cast<whiteout_M2Extent*>(&reinterpret_cast<whiteout::m2::Model*>(self)->bounding);
}

void whiteout_m2_M2Model_set_bounding(whiteout_M2Model* self, const whiteout_M2Extent* value) {
    reinterpret_cast<whiteout::m2::Model*>(self)->bounding = *reinterpret_cast<const whiteout::m2::Extent*>(value);
}

whiteout_M2Extent* whiteout_m2_M2Model_get_collision(whiteout_M2Model* self) {
    return reinterpret_cast<whiteout_M2Extent*>(&reinterpret_cast<whiteout::m2::Model*>(self)->collision);
}

void whiteout_m2_M2Model_set_collision(whiteout_M2Model* self, const whiteout_M2Extent* value) {
    reinterpret_cast<whiteout::m2::Model*>(self)->collision = *reinterpret_cast<const whiteout::m2::Extent*>(value);
}

size_t whiteout_m2_M2Model_get_collisionTriangleIndices_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->collisionTriangleIndices.size();
}

void whiteout_m2_M2Model_resize_collisionTriangleIndices(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->collisionTriangleIndices.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_collisionTriangleIndices_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->collisionTriangleIndices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_collisionTriangleIndices(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->collisionTriangleIndices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_collisionVertices_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->collisionVertices.size();
}

void whiteout_m2_M2Model_resize_collisionVertices(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->collisionVertices.resize(count);
}

const float* whiteout_m2_M2Model_get_collisionVertices_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->collisionVertices;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2Model_assign_collisionVertices(whiteout_M2Model* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->collisionVertices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

size_t whiteout_m2_M2Model_get_collisionFaceNormals_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->collisionFaceNormals.size();
}

void whiteout_m2_M2Model_resize_collisionFaceNormals(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->collisionFaceNormals.resize(count);
}

const float* whiteout_m2_M2Model_get_collisionFaceNormals_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->collisionFaceNormals;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2Model_assign_collisionFaceNormals(whiteout_M2Model* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->collisionFaceNormals;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

size_t whiteout_m2_M2Model_get_attachments_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->attachments.size();
}

void whiteout_m2_M2Model_resize_attachments(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->attachments.resize(count);
}

whiteout_M2Attachment* whiteout_m2_M2Model_get_attachments_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Attachment*>(&reinterpret_cast<whiteout::m2::Model*>(self)->attachments[index]);
}

size_t whiteout_m2_M2Model_get_attachmentIndicesById_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->attachmentIndicesById.size();
}

void whiteout_m2_M2Model_resize_attachmentIndicesById(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->attachmentIndicesById.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_attachmentIndicesById_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->attachmentIndicesById;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_attachmentIndicesById(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->attachmentIndicesById;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_events_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->events.size();
}

void whiteout_m2_M2Model_resize_events(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->events.resize(count);
}

whiteout_M2Event* whiteout_m2_M2Model_get_events_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Event*>(&reinterpret_cast<whiteout::m2::Model*>(self)->events[index]);
}

size_t whiteout_m2_M2Model_get_lights_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->lights.size();
}

void whiteout_m2_M2Model_resize_lights(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->lights.resize(count);
}

whiteout_M2Light* whiteout_m2_M2Model_get_lights_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Light*>(&reinterpret_cast<whiteout::m2::Model*>(self)->lights[index]);
}

size_t whiteout_m2_M2Model_get_cameras_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->cameras.size();
}

void whiteout_m2_M2Model_resize_cameras(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->cameras.resize(count);
}

whiteout_M2Camera* whiteout_m2_M2Model_get_cameras_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Camera*>(&reinterpret_cast<whiteout::m2::Model*>(self)->cameras[index]);
}

size_t whiteout_m2_M2Model_get_cameraIndicesById_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->cameraIndicesById.size();
}

void whiteout_m2_M2Model_resize_cameraIndicesById(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->cameraIndicesById.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_cameraIndicesById_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->cameraIndicesById;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_cameraIndicesById(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->cameraIndicesById;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_ribbonEmitters_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->ribbonEmitters.size();
}

void whiteout_m2_M2Model_resize_ribbonEmitters(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->ribbonEmitters.resize(count);
}

whiteout_M2RibbonEmitter* whiteout_m2_M2Model_get_ribbonEmitters_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2RibbonEmitter*>(&reinterpret_cast<whiteout::m2::Model*>(self)->ribbonEmitters[index]);
}

size_t whiteout_m2_M2Model_get_particleEmitters_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->particleEmitters.size();
}

void whiteout_m2_M2Model_resize_particleEmitters(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->particleEmitters.resize(count);
}

whiteout_M2ParticleEmitter* whiteout_m2_M2Model_get_particleEmitters_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2ParticleEmitter*>(&reinterpret_cast<whiteout::m2::Model*>(self)->particleEmitters[index]);
}

size_t whiteout_m2_M2Model_get_textureCombinerCombos_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->textureCombinerCombos.size();
}

void whiteout_m2_M2Model_resize_textureCombinerCombos(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->textureCombinerCombos.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_textureCombinerCombos_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->textureCombinerCombos;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_textureCombinerCombos(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->textureCombinerCombos;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_texture_ids_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->texture_ids.size();
}

void whiteout_m2_M2Model_resize_texture_ids(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->texture_ids.resize(count);
}

const uint32_t* whiteout_m2_M2Model_get_texture_ids_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->texture_ids;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_texture_ids(whiteout_M2Model* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->texture_ids;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2Model_get_parentSequenceReplacements_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->parentSequenceReplacements.size();
}

void whiteout_m2_M2Model_resize_parentSequenceReplacements(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->parentSequenceReplacements.resize(count);
}

const uint16_t* whiteout_m2_M2Model_get_parentSequenceReplacements_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->parentSequenceReplacements;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_parentSequenceReplacements(whiteout_M2Model* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->parentSequenceReplacements;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_m2_M2Model_get_parentTextureWeights_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->parentTextureWeights.size();
}

void whiteout_m2_M2Model_resize_parentTextureWeights(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->parentTextureWeights.resize(count);
}

whiteout_M2TextureWeight* whiteout_m2_M2Model_get_parentTextureWeights_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2TextureWeight*>(&reinterpret_cast<whiteout::m2::Model*>(self)->parentTextureWeights[index]);
}

size_t whiteout_m2_M2Model_get_parentSequenceBounds_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->parentSequenceBounds.size();
}

void whiteout_m2_M2Model_resize_parentSequenceBounds(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->parentSequenceBounds.resize(count);
}

whiteout_M2Extent* whiteout_m2_M2Model_get_parentSequenceBounds_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2Extent*>(&reinterpret_cast<whiteout::m2::Model*>(self)->parentSequenceBounds[index]);
}

size_t whiteout_m2_M2Model_get_parentEventData_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->parentEventData.size();
}

void whiteout_m2_M2Model_resize_parentEventData(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->parentEventData.resize(count);
}

whiteout_M2AnimationTrackBase* whiteout_m2_M2Model_get_parentEventData_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2AnimationTrackBase*>(&reinterpret_cast<whiteout::m2::Model*>(self)->parentEventData[index]);
}

size_t whiteout_m2_M2Model_get_recursiveParticleModelIds_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->recursiveParticleModelIds.size();
}

void whiteout_m2_M2Model_resize_recursiveParticleModelIds(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->recursiveParticleModelIds.resize(count);
}

const uint32_t* whiteout_m2_M2Model_get_recursiveParticleModelIds_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->recursiveParticleModelIds;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_recursiveParticleModelIds(whiteout_M2Model* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->recursiveParticleModelIds;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2Model_get_geometryParticleModelIds_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->geometryParticleModelIds.size();
}

void whiteout_m2_M2Model_resize_geometryParticleModelIds(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->geometryParticleModelIds.resize(count);
}

const uint32_t* whiteout_m2_M2Model_get_geometryParticleModelIds_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->geometryParticleModelIds;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_geometryParticleModelIds(whiteout_M2Model* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->geometryParticleModelIds;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2Model_get_particleGeosets_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->particleGeosets.size();
}

void whiteout_m2_M2Model_resize_particleGeosets(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->particleGeosets.resize(count);
}

whiteout_M2ParticleGeosetData* whiteout_m2_M2Model_get_particleGeosets_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2ParticleGeosetData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->particleGeosets[index]);
}

size_t whiteout_m2_M2Model_get_physicsFileData_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->physicsFileData.size();
}

void whiteout_m2_M2Model_resize_physicsFileData(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->physicsFileData.resize(count);
}

const uint8_t* whiteout_m2_M2Model_get_physicsFileData_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->physicsFileData;
    return __v.empty() ? nullptr : reinterpret_cast<const uint8_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_physicsFileData(whiteout_M2Model* self, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->physicsFileData;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u8));
}

size_t whiteout_m2_M2Model_get_edgeFadeEntries_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->edgeFadeEntries.size();
}

void whiteout_m2_M2Model_resize_edgeFadeEntries(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->edgeFadeEntries.resize(count);
}

whiteout_M2EdgeFadeData* whiteout_m2_M2Model_get_edgeFadeEntries_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2EdgeFadeData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->edgeFadeEntries[index]);
}

size_t whiteout_m2_M2Model_get_nerfEntries_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->nerfEntries.size();
}

void whiteout_m2_M2Model_resize_nerfEntries(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->nerfEntries.resize(count);
}

whiteout_M2DistanceFadeData* whiteout_m2_M2Model_get_nerfEntries_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2DistanceFadeData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->nerfEntries[index]);
}

size_t whiteout_m2_M2Model_get_detailedLightEntries_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->detailedLightEntries.size();
}

void whiteout_m2_M2Model_resize_detailedLightEntries(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->detailedLightEntries.resize(count);
}

whiteout_M2DetailedLightData* whiteout_m2_M2Model_get_detailedLightEntries_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2DetailedLightData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->detailedLightEntries[index]);
}

size_t whiteout_m2_M2Model_get_debugOcclusionEntries_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->debugOcclusionEntries.size();
}

void whiteout_m2_M2Model_resize_debugOcclusionEntries(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->debugOcclusionEntries.resize(count);
}

whiteout_M2DebugOcclusionData* whiteout_m2_M2Model_get_debugOcclusionEntries_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2DebugOcclusionData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->debugOcclusionEntries[index]);
}

size_t whiteout_m2_M2Model_get_animFrameData_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->animFrameData.size();
}

void whiteout_m2_M2Model_resize_animFrameData(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->animFrameData.resize(count);
}

const uint8_t* whiteout_m2_M2Model_get_animFrameData_data(const whiteout_M2Model* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Model*>(self)->animFrameData;
    return __v.empty() ? nullptr : reinterpret_cast<const uint8_t*>(__v.data());
}

void whiteout_m2_M2Model_assign_animFrameData(whiteout_M2Model* self, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::Model*>(self)->animFrameData;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u8));
}

size_t whiteout_m2_M2Model_get_texturedLightEntries_count(const whiteout_M2Model* self) {
    return reinterpret_cast<const whiteout::m2::Model*>(self)->texturedLightEntries.size();
}

void whiteout_m2_M2Model_resize_texturedLightEntries(whiteout_M2Model* self, size_t count) {
    reinterpret_cast<whiteout::m2::Model*>(self)->texturedLightEntries.resize(count);
}

whiteout_M2TexturedLightData* whiteout_m2_M2Model_get_texturedLightEntries_at(whiteout_M2Model* self, size_t index) {
    return reinterpret_cast<whiteout_M2TexturedLightData*>(&reinterpret_cast<whiteout::m2::Model*>(self)->texturedLightEntries[index]);
}

} // extern "C"

// ── M2Parser ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Parser* whiteout_m2_M2Parser_new(void) {
    return reinterpret_cast<whiteout_M2Parser*>(new whiteout::m2::Parser());
}

void whiteout_m2_M2Parser_delete(whiteout_M2Parser* self) {
    delete reinterpret_cast<whiteout::m2::Parser*>(self);
}

struct whiteout_M2Model* whiteout_m2_M2Parser_parse(whiteout_M2Parser* self, void* fs, const char* filePath) {
    return reinterpret_cast<struct whiteout_M2Model*>(
        new whiteout::m2::Model(reinterpret_cast<whiteout::m2::Parser*>(self)->parse(*reinterpret_cast<whiteout::interfaces::VirtualPathFileSystem*>(fs), std::string(filePath ? filePath : ""))));
}

struct whiteout_M2Model* whiteout_m2_M2Parser_parse_cascFs_buffer(whiteout_M2Parser* self, void* cascFs, const uint8_t* buffer, size_t buffer_size) {
    return reinterpret_cast<struct whiteout_M2Model*>(
        new whiteout::m2::Model(reinterpret_cast<whiteout::m2::Parser*>(self)->parse(*reinterpret_cast<whiteout::interfaces::CascFileSystem*>(cascFs), std::span<const whiteout::u8>(buffer, buffer_size))));
}

int32_t whiteout_m2_M2Parser_hasIssues(const whiteout_M2Parser* self) {
    return reinterpret_cast<const whiteout::m2::Parser*>(self)->hasIssues();
}

size_t whiteout_m2_M2Parser_getIssues_count(const whiteout_M2Parser* self) {
    return reinterpret_cast<const whiteout::m2::Parser*>(self)->getIssues().size();
}

whiteout_CString whiteout_m2_M2Parser_getIssues_at(const whiteout_M2Parser* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Parser*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── M2WriteOptions ─────────────────────────────────────────────────

extern "C" {

whiteout_M2WriteOptions* whiteout_m2_M2WriteOptions_new(void) {
    return reinterpret_cast<whiteout_M2WriteOptions*>(new whiteout::m2::WriteOptions());
}

void whiteout_m2_M2WriteOptions_delete(whiteout_M2WriteOptions* self) {
    delete reinterpret_cast<whiteout::m2::WriteOptions*>(self);
}

uint32_t whiteout_m2_M2WriteOptions_get_m2Version(const whiteout_M2WriteOptions* self) {
    return reinterpret_cast<const whiteout::m2::WriteOptions*>(self)->m2Version;
}

void whiteout_m2_M2WriteOptions_set_m2Version(whiteout_M2WriteOptions* self, uint32_t value) {
    reinterpret_cast<whiteout::m2::WriteOptions*>(self)->m2Version = value;
}

int32_t whiteout_m2_M2WriteOptions_get_emitSkeleton(const whiteout_M2WriteOptions* self) {
    return reinterpret_cast<const whiteout::m2::WriteOptions*>(self)->emitSkeleton;
}

void whiteout_m2_M2WriteOptions_set_emitSkeleton(whiteout_M2WriteOptions* self, int32_t value) {
    reinterpret_cast<whiteout::m2::WriteOptions*>(self)->emitSkeleton = value;
}

whiteout_CString whiteout_m2_M2WriteOptions_get_baseStem(const whiteout_M2WriteOptions* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::m2::WriteOptions*>(self)->baseStem);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_m2_M2WriteOptions_set_baseStem(whiteout_M2WriteOptions* self, const char* value) {
    reinterpret_cast<whiteout::m2::WriteOptions*>(self)->baseStem = (value ? value : "");
}

} // extern "C"

// ── M2SerializeResult ─────────────────────────────────────────────────

extern "C" {

whiteout_M2SerializeResult* whiteout_m2_M2SerializeResult_new(void) {
    return reinterpret_cast<whiteout_M2SerializeResult*>(new whiteout::m2::M2SerializeResult());
}

void whiteout_m2_M2SerializeResult_delete(whiteout_M2SerializeResult* self) {
    delete reinterpret_cast<whiteout::m2::M2SerializeResult*>(self);
}

size_t whiteout_m2_M2SerializeResult_get_m2Data_count(const whiteout_M2SerializeResult* self) {
    return reinterpret_cast<const whiteout::m2::M2SerializeResult*>(self)->m2Data.size();
}

void whiteout_m2_M2SerializeResult_resize_m2Data(whiteout_M2SerializeResult* self, size_t count) {
    reinterpret_cast<whiteout::m2::M2SerializeResult*>(self)->m2Data.resize(count);
}

const uint8_t* whiteout_m2_M2SerializeResult_get_m2Data_data(const whiteout_M2SerializeResult* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::M2SerializeResult*>(self)->m2Data;
    return __v.empty() ? nullptr : reinterpret_cast<const uint8_t*>(__v.data());
}

void whiteout_m2_M2SerializeResult_assign_m2Data(whiteout_M2SerializeResult* self, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::M2SerializeResult*>(self)->m2Data;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u8));
}

} // extern "C"

// ── M2Writer ─────────────────────────────────────────────────

extern "C" {

whiteout_M2Writer* whiteout_m2_M2Writer_new(void) {
    return reinterpret_cast<whiteout_M2Writer*>(new whiteout::m2::Writer());
}

whiteout_M2Writer* whiteout_m2_M2Writer_new_options(struct whiteout_M2WriteOptions* options) {
    return reinterpret_cast<whiteout_M2Writer*>(new whiteout::m2::Writer(*reinterpret_cast<whiteout::m2::WriteOptions*>(options)));
}

void whiteout_m2_M2Writer_delete(whiteout_M2Writer* self) {
    delete reinterpret_cast<whiteout::m2::Writer*>(self);
}

void whiteout_m2_M2Writer_write(whiteout_M2Writer* self, void* fs, const char* filePath, struct whiteout_M2Model* model) {
    reinterpret_cast<whiteout::m2::Writer*>(self)->write(*reinterpret_cast<whiteout::interfaces::VirtualPathFileSystem*>(fs), std::string(filePath ? filePath : ""), *reinterpret_cast<const whiteout::m2::Model*>(model));
}

void whiteout_m2_M2Writer_write_cascFs_model(whiteout_M2Writer* self, void* cascFs, struct whiteout_M2Model* model) {
    reinterpret_cast<whiteout::m2::Writer*>(self)->write(*reinterpret_cast<whiteout::interfaces::CascFileSystem*>(cascFs), *reinterpret_cast<const whiteout::m2::Model*>(model));
}

struct whiteout_M2SerializeResult* whiteout_m2_M2Writer_write_model(whiteout_M2Writer* self, struct whiteout_M2Model* model) {
    return reinterpret_cast<struct whiteout_M2SerializeResult*>(
        new whiteout::m2::M2SerializeResult(reinterpret_cast<whiteout::m2::Writer*>(self)->write(*reinterpret_cast<const whiteout::m2::Model*>(model))));
}

int32_t whiteout_m2_M2Writer_hasIssues(const whiteout_M2Writer* self) {
    return reinterpret_cast<const whiteout::m2::Writer*>(self)->hasIssues();
}

size_t whiteout_m2_M2Writer_getIssues_count(const whiteout_M2Writer* self) {
    return reinterpret_cast<const whiteout::m2::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_m2_M2Writer_getIssues_at(const whiteout_M2Writer* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::m2::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── M2AnimationTrackVector3f ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackVector3f* whiteout_m2_M2AnimationTrackVector3f_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackVector3f*>(new whiteout::m2::AnimationTrack<whiteout::Vector3f>());
}

void whiteout_m2_M2AnimationTrackVector3f_delete(whiteout_M2AnimationTrackVector3f* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackVector3f_get_interpolationType(const whiteout_M2AnimationTrackVector3f* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackVector3f_set_interpolationType(whiteout_M2AnimationTrackVector3f* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackVector3f_get_globalSequenceId(const whiteout_M2AnimationTrackVector3f* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackVector3f_set_globalSequenceId(whiteout_M2AnimationTrackVector3f* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackVector3f_get_timestamps_count(const whiteout_M2AnimationTrackVector3f* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_count(const whiteout_M2AnimationTrackVector3f* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackVector3f_resize_timestamps(whiteout_M2AnimationTrackVector3f* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackVector3f_resize_timestamps_inner(whiteout_M2AnimationTrackVector3f* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackVector3f_get_timestamps_inner_data(const whiteout_M2AnimationTrackVector3f* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackVector3f_assign_timestamps_inner(whiteout_M2AnimationTrackVector3f* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackVector3f_get_values_count(const whiteout_M2AnimationTrackVector3f* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackVector3f_get_values_inner_count(const whiteout_M2AnimationTrackVector3f* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackVector3f_resize_values(whiteout_M2AnimationTrackVector3f* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackVector3f_resize_values_inner(whiteout_M2AnimationTrackVector3f* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const float* whiteout_m2_M2AnimationTrackVector3f_get_values_inner_data(const whiteout_M2AnimationTrackVector3f* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const float*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackVector3f_assign_values_inner(whiteout_M2AnimationTrackVector3f* self, size_t outer_idx, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::Vector3f>*>(self)->values;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::Vector3f));
}

} // extern "C"

// ── M2AnimationTrackM2CompatQuaternion ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackM2CompatQuaternion* whiteout_m2_M2AnimationTrackM2CompatQuaternion_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CompatQuaternion*>(new whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>());
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_delete(whiteout_M2AnimationTrackM2CompatQuaternion* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_interpolationType(const whiteout_M2AnimationTrackM2CompatQuaternion* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_interpolationType(whiteout_M2AnimationTrackM2CompatQuaternion* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_globalSequenceId(const whiteout_M2AnimationTrackM2CompatQuaternion* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_set_globalSequenceId(whiteout_M2AnimationTrackM2CompatQuaternion* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_count(const whiteout_M2AnimationTrackM2CompatQuaternion* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_count(const whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_timestamps_inner(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_timestamps_inner_data(const whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_assign_timestamps_inner(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_count(const whiteout_M2AnimationTrackM2CompatQuaternion* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_inner_count(const whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackM2CompatQuaternion_resize_values_inner(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

whiteout_M2CompatQuaternion* whiteout_m2_M2AnimationTrackM2CompatQuaternion_get_values_at(whiteout_M2AnimationTrackM2CompatQuaternion* self, size_t outer_idx, size_t inner_idx) {
    return reinterpret_cast<whiteout_M2CompatQuaternion*>(&reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CompatQuaternion>*>(self)->values[outer_idx][inner_idx]);
}

} // extern "C"

// ── M2AnimationTrackI16 ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackI16* whiteout_m2_M2AnimationTrackI16_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackI16*>(new whiteout::m2::AnimationTrack<whiteout::i16>());
}

void whiteout_m2_M2AnimationTrackI16_delete(whiteout_M2AnimationTrackI16* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackI16_get_interpolationType(const whiteout_M2AnimationTrackI16* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackI16_set_interpolationType(whiteout_M2AnimationTrackI16* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackI16_get_globalSequenceId(const whiteout_M2AnimationTrackI16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackI16_set_globalSequenceId(whiteout_M2AnimationTrackI16* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackI16_get_timestamps_count(const whiteout_M2AnimationTrackI16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_count(const whiteout_M2AnimationTrackI16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackI16_resize_timestamps(whiteout_M2AnimationTrackI16* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackI16_resize_timestamps_inner(whiteout_M2AnimationTrackI16* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackI16_get_timestamps_inner_data(const whiteout_M2AnimationTrackI16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackI16_assign_timestamps_inner(whiteout_M2AnimationTrackI16* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackI16_get_values_count(const whiteout_M2AnimationTrackI16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackI16_get_values_inner_count(const whiteout_M2AnimationTrackI16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackI16_resize_values(whiteout_M2AnimationTrackI16* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackI16_resize_values_inner(whiteout_M2AnimationTrackI16* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const int16_t* whiteout_m2_M2AnimationTrackI16_get_values_inner_data(const whiteout_M2AnimationTrackI16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const int16_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackI16_assign_values_inner(whiteout_M2AnimationTrackI16* self, size_t outer_idx, const int16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::i16>*>(self)->values;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::i16));
}

} // extern "C"

// ── M2AnimationTrackF32 ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackF32* whiteout_m2_M2AnimationTrackF32_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackF32*>(new whiteout::m2::AnimationTrack<whiteout::f32>());
}

void whiteout_m2_M2AnimationTrackF32_delete(whiteout_M2AnimationTrackF32* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackF32_get_interpolationType(const whiteout_M2AnimationTrackF32* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackF32_set_interpolationType(whiteout_M2AnimationTrackF32* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackF32_get_globalSequenceId(const whiteout_M2AnimationTrackF32* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackF32_set_globalSequenceId(whiteout_M2AnimationTrackF32* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackF32_get_timestamps_count(const whiteout_M2AnimationTrackF32* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_count(const whiteout_M2AnimationTrackF32* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackF32_resize_timestamps(whiteout_M2AnimationTrackF32* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackF32_resize_timestamps_inner(whiteout_M2AnimationTrackF32* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackF32_get_timestamps_inner_data(const whiteout_M2AnimationTrackF32* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackF32_assign_timestamps_inner(whiteout_M2AnimationTrackF32* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackF32_get_values_count(const whiteout_M2AnimationTrackF32* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackF32_get_values_inner_count(const whiteout_M2AnimationTrackF32* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackF32_resize_values(whiteout_M2AnimationTrackF32* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackF32_resize_values_inner(whiteout_M2AnimationTrackF32* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const float* whiteout_m2_M2AnimationTrackF32_get_values_inner_data(const whiteout_M2AnimationTrackF32* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const float*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackF32_assign_values_inner(whiteout_M2AnimationTrackF32* self, size_t outer_idx, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::f32>*>(self)->values;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::f32));
}

} // extern "C"

// ── M2AnimationTrackU8 ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackU8* whiteout_m2_M2AnimationTrackU8_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackU8*>(new whiteout::m2::AnimationTrack<whiteout::u8>());
}

void whiteout_m2_M2AnimationTrackU8_delete(whiteout_M2AnimationTrackU8* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackU8_get_interpolationType(const whiteout_M2AnimationTrackU8* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackU8_set_interpolationType(whiteout_M2AnimationTrackU8* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackU8_get_globalSequenceId(const whiteout_M2AnimationTrackU8* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackU8_set_globalSequenceId(whiteout_M2AnimationTrackU8* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackU8_get_timestamps_count(const whiteout_M2AnimationTrackU8* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_count(const whiteout_M2AnimationTrackU8* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackU8_resize_timestamps(whiteout_M2AnimationTrackU8* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackU8_resize_timestamps_inner(whiteout_M2AnimationTrackU8* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackU8_get_timestamps_inner_data(const whiteout_M2AnimationTrackU8* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackU8_assign_timestamps_inner(whiteout_M2AnimationTrackU8* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackU8_get_values_count(const whiteout_M2AnimationTrackU8* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackU8_get_values_inner_count(const whiteout_M2AnimationTrackU8* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackU8_resize_values(whiteout_M2AnimationTrackU8* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackU8_resize_values_inner(whiteout_M2AnimationTrackU8* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint8_t* whiteout_m2_M2AnimationTrackU8_get_values_inner_data(const whiteout_M2AnimationTrackU8* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint8_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackU8_assign_values_inner(whiteout_M2AnimationTrackU8* self, size_t outer_idx, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u8>*>(self)->values;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u8));
}

} // extern "C"

// ── M2AnimationTrackM2CameraSpline ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackM2CameraSpline* whiteout_m2_M2AnimationTrackM2CameraSpline_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackM2CameraSpline*>(new whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>());
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_delete(whiteout_M2AnimationTrackM2CameraSpline* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_interpolationType(const whiteout_M2AnimationTrackM2CameraSpline* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_set_interpolationType(whiteout_M2AnimationTrackM2CameraSpline* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_globalSequenceId(const whiteout_M2AnimationTrackM2CameraSpline* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_set_globalSequenceId(whiteout_M2AnimationTrackM2CameraSpline* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_count(const whiteout_M2AnimationTrackM2CameraSpline* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_count(const whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps(whiteout_M2AnimationTrackM2CameraSpline* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_resize_timestamps_inner(whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackM2CameraSpline_get_timestamps_inner_data(const whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_assign_timestamps_inner(whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_count(const whiteout_M2AnimationTrackM2CameraSpline* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_inner_count(const whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values(whiteout_M2AnimationTrackM2CameraSpline* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackM2CameraSpline_resize_values_inner(whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

whiteout_M2CameraSpline* whiteout_m2_M2AnimationTrackM2CameraSpline_get_values_at(whiteout_M2AnimationTrackM2CameraSpline* self, size_t outer_idx, size_t inner_idx) {
    return reinterpret_cast<whiteout_M2CameraSpline*>(&reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::m2::CameraSpline>*>(self)->values[outer_idx][inner_idx]);
}

} // extern "C"

// ── M2AnimationTrackU16 ─────────────────────────────────────────────────

extern "C" {

whiteout_M2AnimationTrackU16* whiteout_m2_M2AnimationTrackU16_new(void) {
    return reinterpret_cast<whiteout_M2AnimationTrackU16*>(new whiteout::m2::AnimationTrack<whiteout::u16>());
}

void whiteout_m2_M2AnimationTrackU16_delete(whiteout_M2AnimationTrackU16* self) {
    delete reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self);
}

int32_t whiteout_m2_M2AnimationTrackU16_get_interpolationType(const whiteout_M2AnimationTrackU16* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->interpolationType);
}

void whiteout_m2_M2AnimationTrackU16_set_interpolationType(whiteout_M2AnimationTrackU16* self, int32_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->interpolationType = static_cast<whiteout::m2::InterpolationType>(value);
}

uint16_t whiteout_m2_M2AnimationTrackU16_get_globalSequenceId(const whiteout_M2AnimationTrackU16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->globalSequenceId;
}

void whiteout_m2_M2AnimationTrackU16_set_globalSequenceId(whiteout_M2AnimationTrackU16* self, uint16_t value) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->globalSequenceId = value;
}

size_t whiteout_m2_M2AnimationTrackU16_get_timestamps_count(const whiteout_M2AnimationTrackU16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps.size();
}

size_t whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_count(const whiteout_M2AnimationTrackU16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackU16_resize_timestamps(whiteout_M2AnimationTrackU16* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps.resize(count);
}

void whiteout_m2_M2AnimationTrackU16_resize_timestamps_inner(whiteout_M2AnimationTrackU16* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint32_t* whiteout_m2_M2AnimationTrackU16_get_timestamps_inner_data(const whiteout_M2AnimationTrackU16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint32_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackU16_assign_timestamps_inner(whiteout_M2AnimationTrackU16* self, size_t outer_idx, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->timestamps;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_m2_M2AnimationTrackU16_get_values_count(const whiteout_M2AnimationTrackU16* self) {
    return reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values.size();
}

size_t whiteout_m2_M2AnimationTrackU16_get_values_inner_count(const whiteout_M2AnimationTrackU16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_m2_M2AnimationTrackU16_resize_values(whiteout_M2AnimationTrackU16* self, size_t count) {
    reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values.resize(count);
}

void whiteout_m2_M2AnimationTrackU16_resize_values_inner(whiteout_M2AnimationTrackU16* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const uint16_t* whiteout_m2_M2AnimationTrackU16_get_values_inner_data(const whiteout_M2AnimationTrackU16* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const uint16_t*>(__v[outer_idx].data());
}

void whiteout_m2_M2AnimationTrackU16_assign_values_inner(whiteout_M2AnimationTrackU16* self, size_t outer_idx, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::AnimationTrack<whiteout::u16>*>(self)->values;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::u16));
}

} // extern "C"

// ── M2ParticleAnimationTrackVector3f ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ParticleAnimationTrackVector3f* whiteout_m2_M2ParticleAnimationTrackVector3f_new(void) {
    return reinterpret_cast<whiteout_M2ParticleAnimationTrackVector3f*>(new whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>());
}

void whiteout_m2_M2ParticleAnimationTrackVector3f_delete(whiteout_M2ParticleAnimationTrackVector3f* self) {
    delete reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(self);
}

size_t whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_count(const whiteout_M2ParticleAnimationTrackVector3f* self) {
    return reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(self)->values.size();
}

void whiteout_m2_M2ParticleAnimationTrackVector3f_resize_values(whiteout_M2ParticleAnimationTrackVector3f* self, size_t count) {
    reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(self)->values.resize(count);
}

const float* whiteout_m2_M2ParticleAnimationTrackVector3f_get_values_data(const whiteout_M2ParticleAnimationTrackVector3f* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(self)->values;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2ParticleAnimationTrackVector3f_assign_values(whiteout_M2ParticleAnimationTrackVector3f* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector3f>*>(self)->values;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

} // extern "C"

// ── M2ParticleAnimationTrackVector2f ─────────────────────────────────────────────────

extern "C" {

whiteout_M2ParticleAnimationTrackVector2f* whiteout_m2_M2ParticleAnimationTrackVector2f_new(void) {
    return reinterpret_cast<whiteout_M2ParticleAnimationTrackVector2f*>(new whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>());
}

void whiteout_m2_M2ParticleAnimationTrackVector2f_delete(whiteout_M2ParticleAnimationTrackVector2f* self) {
    delete reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(self);
}

size_t whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_count(const whiteout_M2ParticleAnimationTrackVector2f* self) {
    return reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(self)->values.size();
}

void whiteout_m2_M2ParticleAnimationTrackVector2f_resize_values(whiteout_M2ParticleAnimationTrackVector2f* self, size_t count) {
    reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(self)->values.resize(count);
}

const float* whiteout_m2_M2ParticleAnimationTrackVector2f_get_values_data(const whiteout_M2ParticleAnimationTrackVector2f* self) {
    const auto& __v = reinterpret_cast<const whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(self)->values;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_m2_M2ParticleAnimationTrackVector2f_assign_values(whiteout_M2ParticleAnimationTrackVector2f* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::m2::ParticleAnimationTrack<whiteout::Vector2f>*>(self)->values;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector2f));
}

} // extern "C"