whiteoutlib 0.1.1

// 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 mdx --backend c-source

#include "whiteout_mdx.h"

#include <cstring>
#include <new>
#include <span>
#include <string>
#include <vector>

#include <whiteout/vector_types.h>
#include <whiteout/models/mdx/types.h>
#include <whiteout/models/mdx/structures.h>
#include <whiteout/models/mdx/parser.h>
#include <whiteout/models/mdx/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
// ── MdxExtent ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxExtent* whiteout_mdx_MdxExtent_new(void) {
    return reinterpret_cast<whiteout_MdxExtent*>(new whiteout::mdx::Extent());
}

void whiteout_mdx_MdxExtent_delete(whiteout_MdxExtent* self) {
    delete reinterpret_cast<whiteout::mdx::Extent*>(self);
}

float whiteout_mdx_MdxExtent_get_boundsRadius(const whiteout_MdxExtent* self) {
    return reinterpret_cast<const whiteout::mdx::Extent*>(self)->boundsRadius;
}

void whiteout_mdx_MdxExtent_set_boundsRadius(whiteout_MdxExtent* self, float value) {
    reinterpret_cast<whiteout::mdx::Extent*>(self)->boundsRadius = value;
}

whiteout_Vector3f* whiteout_mdx_MdxExtent_get_minimum(whiteout_MdxExtent* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Extent*>(self)->minimum);
}

void whiteout_mdx_MdxExtent_set_minimum(whiteout_MdxExtent* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Extent*>(self)->minimum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_Vector3f* whiteout_mdx_MdxExtent_get_maximum(whiteout_MdxExtent* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Extent*>(self)->maximum);
}

void whiteout_mdx_MdxExtent_set_maximum(whiteout_MdxExtent* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Extent*>(self)->maximum = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

} // extern "C"

// ── MdxModel ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxModel* whiteout_mdx_MdxModel_new(void) {
    return reinterpret_cast<whiteout_MdxModel*>(new whiteout::mdx::Model());
}

void whiteout_mdx_MdxModel_delete(whiteout_MdxModel* self) {
    delete reinterpret_cast<whiteout::mdx::Model*>(self);
}

uint32_t whiteout_mdx_MdxModel_get_version(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->version;
}

void whiteout_mdx_MdxModel_set_version(whiteout_MdxModel* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->version = value;
}

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

void whiteout_mdx_MdxModel_set_modelName(whiteout_MdxModel* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->modelName = (value ? value : "");
}

whiteout_CString whiteout_mdx_MdxModel_get_animationFileName(const whiteout_MdxModel* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Model*>(self)->animationFileName);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxModel_set_animationFileName(whiteout_MdxModel* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->animationFileName = (value ? value : "");
}

whiteout_MdxExtent* whiteout_mdx_MdxModel_get_modelExtent(whiteout_MdxModel* self) {
    return reinterpret_cast<whiteout_MdxExtent*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->modelExtent);
}

void whiteout_mdx_MdxModel_set_modelExtent(whiteout_MdxModel* self, const whiteout_MdxExtent* value) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->modelExtent = *reinterpret_cast<const whiteout::mdx::Extent*>(value);
}

uint32_t whiteout_mdx_MdxModel_get_blendTime(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->blendTime;
}

void whiteout_mdx_MdxModel_set_blendTime(whiteout_MdxModel* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->blendTime = value;
}

size_t whiteout_mdx_MdxModel_get_globalSequences_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->globalSequences.size();
}

void whiteout_mdx_MdxModel_resize_globalSequences(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->globalSequences.resize(count);
}

const uint32_t* whiteout_mdx_MdxModel_get_globalSequences_data(const whiteout_MdxModel* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Model*>(self)->globalSequences;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

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

size_t whiteout_mdx_MdxModel_get_sequences_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->sequences.size();
}

void whiteout_mdx_MdxModel_resize_sequences(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->sequences.resize(count);
}

whiteout_MdxSequence* whiteout_mdx_MdxModel_get_sequences_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxSequence*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->sequences[index]);
}

size_t whiteout_mdx_MdxModel_get_textures_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->textures.size();
}

void whiteout_mdx_MdxModel_resize_textures(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->textures.resize(count);
}

whiteout_MdxTexture* whiteout_mdx_MdxModel_get_textures_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxTexture*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->textures[index]);
}

size_t whiteout_mdx_MdxModel_get_sounds_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->sounds.size();
}

void whiteout_mdx_MdxModel_resize_sounds(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->sounds.resize(count);
}

whiteout_MdxSound* whiteout_mdx_MdxModel_get_sounds_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxSound*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->sounds[index]);
}

size_t whiteout_mdx_MdxModel_get_soundEmitters_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->soundEmitters.size();
}

void whiteout_mdx_MdxModel_resize_soundEmitters(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->soundEmitters.resize(count);
}

whiteout_MdxSoundEmitter* whiteout_mdx_MdxModel_get_soundEmitters_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxSoundEmitter*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->soundEmitters[index]);
}

size_t whiteout_mdx_MdxModel_get_materials_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->materials.size();
}

void whiteout_mdx_MdxModel_resize_materials(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->materials.resize(count);
}

whiteout_MdxMaterial* whiteout_mdx_MdxModel_get_materials_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxMaterial*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->materials[index]);
}

size_t whiteout_mdx_MdxModel_get_textureAnimations_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->textureAnimations.size();
}

void whiteout_mdx_MdxModel_resize_textureAnimations(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->textureAnimations.resize(count);
}

whiteout_MdxTextureAnimation* whiteout_mdx_MdxModel_get_textureAnimations_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxTextureAnimation*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->textureAnimations[index]);
}

size_t whiteout_mdx_MdxModel_get_geosets_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->geosets.size();
}

void whiteout_mdx_MdxModel_resize_geosets(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->geosets.resize(count);
}

whiteout_MdxGeoset* whiteout_mdx_MdxModel_get_geosets_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxGeoset*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->geosets[index]);
}

size_t whiteout_mdx_MdxModel_get_geosetAnimations_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->geosetAnimations.size();
}

void whiteout_mdx_MdxModel_resize_geosetAnimations(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->geosetAnimations.resize(count);
}

whiteout_MdxGeosetAnimation* whiteout_mdx_MdxModel_get_geosetAnimations_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxGeosetAnimation*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->geosetAnimations[index]);
}

size_t whiteout_mdx_MdxModel_get_bones_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->bones.size();
}

void whiteout_mdx_MdxModel_resize_bones(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->bones.resize(count);
}

whiteout_MdxBone* whiteout_mdx_MdxModel_get_bones_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxBone*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->bones[index]);
}

size_t whiteout_mdx_MdxModel_get_helpers_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->helpers.size();
}

void whiteout_mdx_MdxModel_resize_helpers(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->helpers.resize(count);
}

whiteout_MdxHelper* whiteout_mdx_MdxModel_get_helpers_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxHelper*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->helpers[index]);
}

size_t whiteout_mdx_MdxModel_get_attachments_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->attachments.size();
}

void whiteout_mdx_MdxModel_resize_attachments(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->attachments.resize(count);
}

whiteout_MdxAttachment* whiteout_mdx_MdxModel_get_attachments_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxAttachment*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->attachments[index]);
}

size_t whiteout_mdx_MdxModel_get_pivotPoints_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->pivotPoints.size();
}

void whiteout_mdx_MdxModel_resize_pivotPoints(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->pivotPoints.resize(count);
}

const float* whiteout_mdx_MdxModel_get_pivotPoints_data(const whiteout_MdxModel* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Model*>(self)->pivotPoints;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

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

size_t whiteout_mdx_MdxModel_get_lights_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->lights.size();
}

void whiteout_mdx_MdxModel_resize_lights(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->lights.resize(count);
}

whiteout_MdxLight* whiteout_mdx_MdxModel_get_lights_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxLight*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->lights[index]);
}

size_t whiteout_mdx_MdxModel_get_particleEmitters_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->particleEmitters.size();
}

void whiteout_mdx_MdxModel_resize_particleEmitters(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->particleEmitters.resize(count);
}

whiteout_MdxParticleEmitter* whiteout_mdx_MdxModel_get_particleEmitters_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxParticleEmitter*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->particleEmitters[index]);
}

size_t whiteout_mdx_MdxModel_get_particleEmitters2_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->particleEmitters2.size();
}

void whiteout_mdx_MdxModel_resize_particleEmitters2(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->particleEmitters2.resize(count);
}

whiteout_MdxParticleEmitter2* whiteout_mdx_MdxModel_get_particleEmitters2_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxParticleEmitter2*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->particleEmitters2[index]);
}

size_t whiteout_mdx_MdxModel_get_ribbonEmitters_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->ribbonEmitters.size();
}

void whiteout_mdx_MdxModel_resize_ribbonEmitters(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->ribbonEmitters.resize(count);
}

whiteout_MdxRibbonEmitter* whiteout_mdx_MdxModel_get_ribbonEmitters_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxRibbonEmitter*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->ribbonEmitters[index]);
}

size_t whiteout_mdx_MdxModel_get_cornEmitters_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->cornEmitters.size();
}

void whiteout_mdx_MdxModel_resize_cornEmitters(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->cornEmitters.resize(count);
}

whiteout_MdxCornEmitter* whiteout_mdx_MdxModel_get_cornEmitters_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxCornEmitter*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->cornEmitters[index]);
}

size_t whiteout_mdx_MdxModel_get_eventObjects_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->eventObjects.size();
}

void whiteout_mdx_MdxModel_resize_eventObjects(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->eventObjects.resize(count);
}

whiteout_MdxEventObject* whiteout_mdx_MdxModel_get_eventObjects_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxEventObject*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->eventObjects[index]);
}

size_t whiteout_mdx_MdxModel_get_cameras_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->cameras.size();
}

void whiteout_mdx_MdxModel_resize_cameras(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->cameras.resize(count);
}

whiteout_MdxCamera* whiteout_mdx_MdxModel_get_cameras_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxCamera*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->cameras[index]);
}

size_t whiteout_mdx_MdxModel_get_collisionShapes_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->collisionShapes.size();
}

void whiteout_mdx_MdxModel_resize_collisionShapes(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->collisionShapes.resize(count);
}

whiteout_MdxCollisionShape* whiteout_mdx_MdxModel_get_collisionShapes_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxCollisionShape*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->collisionShapes[index]);
}

size_t whiteout_mdx_MdxModel_get_faceEffects_count(const whiteout_MdxModel* self) {
    return reinterpret_cast<const whiteout::mdx::Model*>(self)->faceEffects.size();
}

void whiteout_mdx_MdxModel_resize_faceEffects(whiteout_MdxModel* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Model*>(self)->faceEffects.resize(count);
}

whiteout_MdxFaceEffect* whiteout_mdx_MdxModel_get_faceEffects_at(whiteout_MdxModel* self, size_t index) {
    return reinterpret_cast<whiteout_MdxFaceEffect*>(&reinterpret_cast<whiteout::mdx::Model*>(self)->faceEffects[index]);
}

} // extern "C"

// ── MdxSequence ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxSequence* whiteout_mdx_MdxSequence_new(void) {
    return reinterpret_cast<whiteout_MdxSequence*>(new whiteout::mdx::Sequence());
}

void whiteout_mdx_MdxSequence_delete(whiteout_MdxSequence* self) {
    delete reinterpret_cast<whiteout::mdx::Sequence*>(self);
}

whiteout_CString whiteout_mdx_MdxSequence_get_name(const whiteout_MdxSequence* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Sequence*>(self)->name);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxSequence_set_name(whiteout_MdxSequence* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->name = (value ? value : "");
}

uint32_t whiteout_mdx_MdxSequence_get_intervalStart(const whiteout_MdxSequence* self) {
    return reinterpret_cast<const whiteout::mdx::Sequence*>(self)->intervalStart;
}

void whiteout_mdx_MdxSequence_set_intervalStart(whiteout_MdxSequence* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->intervalStart = value;
}

uint32_t whiteout_mdx_MdxSequence_get_intervalEnd(const whiteout_MdxSequence* self) {
    return reinterpret_cast<const whiteout::mdx::Sequence*>(self)->intervalEnd;
}

void whiteout_mdx_MdxSequence_set_intervalEnd(whiteout_MdxSequence* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->intervalEnd = value;
}

float whiteout_mdx_MdxSequence_get_moveSpeed(const whiteout_MdxSequence* self) {
    return reinterpret_cast<const whiteout::mdx::Sequence*>(self)->moveSpeed;
}

void whiteout_mdx_MdxSequence_set_moveSpeed(whiteout_MdxSequence* self, float value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->moveSpeed = value;
}

int32_t whiteout_mdx_MdxSequence_get_flags(const whiteout_MdxSequence* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Sequence*>(self)->flags);
}

void whiteout_mdx_MdxSequence_set_flags(whiteout_MdxSequence* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->flags = static_cast<whiteout::mdx::Sequence::Flag>(value);
}

float whiteout_mdx_MdxSequence_get_rarity(const whiteout_MdxSequence* self) {
    return reinterpret_cast<const whiteout::mdx::Sequence*>(self)->rarity;
}

void whiteout_mdx_MdxSequence_set_rarity(whiteout_MdxSequence* self, float value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->rarity = value;
}

uint32_t whiteout_mdx_MdxSequence_get_syncPoint(const whiteout_MdxSequence* self) {
    return reinterpret_cast<const whiteout::mdx::Sequence*>(self)->syncPoint;
}

void whiteout_mdx_MdxSequence_set_syncPoint(whiteout_MdxSequence* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->syncPoint = value;
}

whiteout_MdxExtent* whiteout_mdx_MdxSequence_get_extent(whiteout_MdxSequence* self) {
    return reinterpret_cast<whiteout_MdxExtent*>(&reinterpret_cast<whiteout::mdx::Sequence*>(self)->extent);
}

void whiteout_mdx_MdxSequence_set_extent(whiteout_MdxSequence* self, const whiteout_MdxExtent* value) {
    reinterpret_cast<whiteout::mdx::Sequence*>(self)->extent = *reinterpret_cast<const whiteout::mdx::Extent*>(value);
}

} // extern "C"

// ── MdxTexture ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTexture* whiteout_mdx_MdxTexture_new(void) {
    return reinterpret_cast<whiteout_MdxTexture*>(new whiteout::mdx::Texture());
}

void whiteout_mdx_MdxTexture_delete(whiteout_MdxTexture* self) {
    delete reinterpret_cast<whiteout::mdx::Texture*>(self);
}

uint32_t whiteout_mdx_MdxTexture_get_replaceableId(const whiteout_MdxTexture* self) {
    return reinterpret_cast<const whiteout::mdx::Texture*>(self)->replaceableId;
}

void whiteout_mdx_MdxTexture_set_replaceableId(whiteout_MdxTexture* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Texture*>(self)->replaceableId = value;
}

whiteout_CString whiteout_mdx_MdxTexture_get_fileName(const whiteout_MdxTexture* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Texture*>(self)->fileName);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxTexture_set_fileName(whiteout_MdxTexture* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Texture*>(self)->fileName = (value ? value : "");
}

int32_t whiteout_mdx_MdxTexture_get_flags(const whiteout_MdxTexture* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Texture*>(self)->flags);
}

void whiteout_mdx_MdxTexture_set_flags(whiteout_MdxTexture* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Texture*>(self)->flags = static_cast<whiteout::mdx::Texture::Flag>(value);
}

} // extern "C"

// ── MdxSound ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxSound* whiteout_mdx_MdxSound_new(void) {
    return reinterpret_cast<whiteout_MdxSound*>(new whiteout::mdx::Sound());
}

void whiteout_mdx_MdxSound_delete(whiteout_MdxSound* self) {
    delete reinterpret_cast<whiteout::mdx::Sound*>(self);
}

whiteout_CString whiteout_mdx_MdxSound_get_soundFile(const whiteout_MdxSound* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Sound*>(self)->soundFile);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxSound_set_soundFile(whiteout_MdxSound* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Sound*>(self)->soundFile = (value ? value : "");
}

float whiteout_mdx_MdxSound_get_maximumDistance(const whiteout_MdxSound* self) {
    return reinterpret_cast<const whiteout::mdx::Sound*>(self)->maximumDistance;
}

void whiteout_mdx_MdxSound_set_maximumDistance(whiteout_MdxSound* self, float value) {
    reinterpret_cast<whiteout::mdx::Sound*>(self)->maximumDistance = value;
}

float whiteout_mdx_MdxSound_get_minimumDistance(const whiteout_MdxSound* self) {
    return reinterpret_cast<const whiteout::mdx::Sound*>(self)->minimumDistance;
}

void whiteout_mdx_MdxSound_set_minimumDistance(whiteout_MdxSound* self, float value) {
    reinterpret_cast<whiteout::mdx::Sound*>(self)->minimumDistance = value;
}

uint32_t whiteout_mdx_MdxSound_get_soundChannel(const whiteout_MdxSound* self) {
    return reinterpret_cast<const whiteout::mdx::Sound*>(self)->soundChannel;
}

void whiteout_mdx_MdxSound_set_soundChannel(whiteout_MdxSound* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Sound*>(self)->soundChannel = value;
}

} // extern "C"

// ── MdxNode ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxNode* whiteout_mdx_MdxNode_new(void) {
    return reinterpret_cast<whiteout_MdxNode*>(new whiteout::mdx::Node());
}

void whiteout_mdx_MdxNode_delete(whiteout_MdxNode* self) {
    delete reinterpret_cast<whiteout::mdx::Node*>(self);
}

whiteout_CString whiteout_mdx_MdxNode_get_name(const whiteout_MdxNode* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Node*>(self)->name);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxNode_set_name(whiteout_MdxNode* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->name = (value ? value : "");
}

uint32_t whiteout_mdx_MdxNode_get_objectId(const whiteout_MdxNode* self) {
    return reinterpret_cast<const whiteout::mdx::Node*>(self)->objectId;
}

void whiteout_mdx_MdxNode_set_objectId(whiteout_MdxNode* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->objectId = value;
}

uint32_t whiteout_mdx_MdxNode_get_parentId(const whiteout_MdxNode* self) {
    return reinterpret_cast<const whiteout::mdx::Node*>(self)->parentId;
}

void whiteout_mdx_MdxNode_set_parentId(whiteout_MdxNode* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->parentId = value;
}

int32_t whiteout_mdx_MdxNode_get_flags(const whiteout_MdxNode* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Node*>(self)->flags);
}

void whiteout_mdx_MdxNode_set_flags(whiteout_MdxNode* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->flags = static_cast<whiteout::mdx::Node::NodeFlag>(value);
}

int32_t whiteout_mdx_MdxNode_get_type(const whiteout_MdxNode* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Node*>(self)->type);
}

void whiteout_mdx_MdxNode_set_type(whiteout_MdxNode* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->type = static_cast<whiteout::mdx::Node::NodeType>(value);
}

uint32_t whiteout_mdx_MdxNode_get_nodeFamilyId(const whiteout_MdxNode* self) {
    return reinterpret_cast<const whiteout::mdx::Node*>(self)->nodeFamilyId;
}

void whiteout_mdx_MdxNode_set_nodeFamilyId(whiteout_MdxNode* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->nodeFamilyId = value;
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxNode_get_translationTracks(whiteout_MdxNode* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Node*>(self)->translationTracks);
}

void whiteout_mdx_MdxNode_set_translationTracks(whiteout_MdxNode* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->translationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackQuaternion* whiteout_mdx_MdxNode_get_rotationTracks(whiteout_MdxNode* self) {
    return reinterpret_cast<whiteout_MdxTrackQuaternion*>(&reinterpret_cast<whiteout::mdx::Node*>(self)->rotationTracks);
}

void whiteout_mdx_MdxNode_set_rotationTracks(whiteout_MdxNode* self, const whiteout_MdxTrackQuaternion* value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->rotationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxNode_get_scalingTracks(whiteout_MdxNode* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Node*>(self)->scalingTracks);
}

void whiteout_mdx_MdxNode_set_scalingTracks(whiteout_MdxNode* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Node*>(self)->scalingTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

} // extern "C"

// ── MdxSoundEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxSoundEmitter* whiteout_mdx_MdxSoundEmitter_new(void) {
    return reinterpret_cast<whiteout_MdxSoundEmitter*>(new whiteout::mdx::SoundEmitter());
}

void whiteout_mdx_MdxSoundEmitter_delete(whiteout_MdxSoundEmitter* self) {
    delete reinterpret_cast<whiteout::mdx::SoundEmitter*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxSoundEmitter_get_node(whiteout_MdxSoundEmitter* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::SoundEmitter*>(self)->node);
}

void whiteout_mdx_MdxSoundEmitter_set_node(whiteout_MdxSoundEmitter* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::SoundEmitter*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

whiteout_MdxTrackU32* whiteout_mdx_MdxSoundEmitter_get_soundTrack(whiteout_MdxSoundEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackU32*>(&reinterpret_cast<whiteout::mdx::SoundEmitter*>(self)->soundTrack);
}

void whiteout_mdx_MdxSoundEmitter_set_soundTrack(whiteout_MdxSoundEmitter* self, const whiteout_MdxTrackU32* value) {
    reinterpret_cast<whiteout::mdx::SoundEmitter*>(self)->soundTrack = *reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(value);
}

} // extern "C"

// ── MdxLayer ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxLayer* whiteout_mdx_MdxLayer_new(void) {
    return reinterpret_cast<whiteout_MdxLayer*>(new whiteout::mdx::Layer());
}

void whiteout_mdx_MdxLayer_delete(whiteout_MdxLayer* self) {
    delete reinterpret_cast<whiteout::mdx::Layer*>(self);
}

int32_t whiteout_mdx_MdxLayer_get_filterMode(const whiteout_MdxLayer* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Layer*>(self)->filterMode);
}

void whiteout_mdx_MdxLayer_set_filterMode(whiteout_MdxLayer* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->filterMode = static_cast<whiteout::mdx::Layer::FilterMode>(value);
}

int32_t whiteout_mdx_MdxLayer_get_shadingFlags(const whiteout_MdxLayer* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Layer*>(self)->shadingFlags);
}

void whiteout_mdx_MdxLayer_set_shadingFlags(whiteout_MdxLayer* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->shadingFlags = static_cast<whiteout::mdx::Layer::ShadingFlag>(value);
}

uint32_t whiteout_mdx_MdxLayer_get_textureId(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->textureId;
}

void whiteout_mdx_MdxLayer_set_textureId(whiteout_MdxLayer* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->textureId = value;
}

uint32_t whiteout_mdx_MdxLayer_get_textureAnimationId(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->textureAnimationId;
}

void whiteout_mdx_MdxLayer_set_textureAnimationId(whiteout_MdxLayer* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->textureAnimationId = value;
}

uint32_t whiteout_mdx_MdxLayer_get_coordId(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->coordId;
}

void whiteout_mdx_MdxLayer_set_coordId(whiteout_MdxLayer* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->coordId = value;
}

float whiteout_mdx_MdxLayer_get_alpha(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->alpha;
}

void whiteout_mdx_MdxLayer_set_alpha(whiteout_MdxLayer* self, float value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->alpha = value;
}

float whiteout_mdx_MdxLayer_get_emissiveGain(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->emissiveGain;
}

void whiteout_mdx_MdxLayer_set_emissiveGain(whiteout_MdxLayer* self, float value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->emissiveGain = value;
}

whiteout_Vector3f* whiteout_mdx_MdxLayer_get_fresnelColor(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelColor);
}

void whiteout_mdx_MdxLayer_set_fresnelColor(whiteout_MdxLayer* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelColor = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxLayer_get_fresnelOpacity(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->fresnelOpacity;
}

void whiteout_mdx_MdxLayer_set_fresnelOpacity(whiteout_MdxLayer* self, float value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelOpacity = value;
}

float whiteout_mdx_MdxLayer_get_fresnelTeamColor(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->fresnelTeamColor;
}

void whiteout_mdx_MdxLayer_set_fresnelTeamColor(whiteout_MdxLayer* self, float value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelTeamColor = value;
}

int32_t whiteout_mdx_MdxLayer_get_shader(const whiteout_MdxLayer* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Layer*>(self)->shader);
}

void whiteout_mdx_MdxLayer_set_shader(whiteout_MdxLayer* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->shader = static_cast<whiteout::mdx::Layer::ShaderType>(value);
}

int32_t whiteout_mdx_MdxLayer_get_isHd(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->is_hd;
}

void whiteout_mdx_MdxLayer_set_isHd(whiteout_MdxLayer* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->is_hd = value;
}

size_t whiteout_mdx_MdxLayer_get_subTextures_count(const whiteout_MdxLayer* self) {
    return reinterpret_cast<const whiteout::mdx::Layer*>(self)->subTextures.size();
}

void whiteout_mdx_MdxLayer_resize_subTextures(whiteout_MdxLayer* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->subTextures.resize(count);
}

whiteout_MdxLayerSubTexture* whiteout_mdx_MdxLayer_get_subTextures_at(whiteout_MdxLayer* self, size_t index) {
    return reinterpret_cast<whiteout_MdxLayerSubTexture*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->subTextures[index]);
}

whiteout_MdxTrackU32* whiteout_mdx_MdxLayer_get_textureIdTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackU32*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->textureIdTracks);
}

void whiteout_mdx_MdxLayer_set_textureIdTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackU32* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->textureIdTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLayer_get_alphaTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->alphaTracks);
}

void whiteout_mdx_MdxLayer_set_alphaTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->alphaTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLayer_get_emissiveGainTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->emissiveGainTracks);
}

void whiteout_mdx_MdxLayer_set_emissiveGainTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->emissiveGainTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxLayer_get_fresnelColorTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelColorTracks);
}

void whiteout_mdx_MdxLayer_set_fresnelColorTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelColorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLayer_get_fresnelAlphaTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelAlphaTracks);
}

void whiteout_mdx_MdxLayer_set_fresnelAlphaTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelAlphaTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLayer_get_fresnelTeamColorTracks(whiteout_MdxLayer* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelTeamColorTracks);
}

void whiteout_mdx_MdxLayer_set_fresnelTeamColorTracks(whiteout_MdxLayer* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Layer*>(self)->fresnelTeamColorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxLayerSubTexture ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxLayerSubTexture* whiteout_mdx_MdxLayerSubTexture_new(void) {
    return reinterpret_cast<whiteout_MdxLayerSubTexture*>(new whiteout::mdx::Layer::SubTexture());
}

void whiteout_mdx_MdxLayerSubTexture_delete(whiteout_MdxLayerSubTexture* self) {
    delete reinterpret_cast<whiteout::mdx::Layer::SubTexture*>(self);
}

uint32_t whiteout_mdx_MdxLayerSubTexture_get_textureId(const whiteout_MdxLayerSubTexture* self) {
    return reinterpret_cast<const whiteout::mdx::Layer::SubTexture*>(self)->textureId;
}

void whiteout_mdx_MdxLayerSubTexture_set_textureId(whiteout_MdxLayerSubTexture* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Layer::SubTexture*>(self)->textureId = value;
}

int32_t whiteout_mdx_MdxLayerSubTexture_get_slot(const whiteout_MdxLayerSubTexture* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Layer::SubTexture*>(self)->slot);
}

void whiteout_mdx_MdxLayerSubTexture_set_slot(whiteout_MdxLayerSubTexture* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Layer::SubTexture*>(self)->slot = static_cast<whiteout::mdx::Layer::SlotType>(value);
}

whiteout_MdxTrackU32* whiteout_mdx_MdxLayerSubTexture_get_tracks(whiteout_MdxLayerSubTexture* self) {
    return reinterpret_cast<whiteout_MdxTrackU32*>(&reinterpret_cast<whiteout::mdx::Layer::SubTexture*>(self)->tracks);
}

void whiteout_mdx_MdxLayerSubTexture_set_tracks(whiteout_MdxLayerSubTexture* self, const whiteout_MdxTrackU32* value) {
    reinterpret_cast<whiteout::mdx::Layer::SubTexture*>(self)->tracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(value);
}

} // extern "C"

// ── MdxMaterial ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxMaterial* whiteout_mdx_MdxMaterial_new(void) {
    return reinterpret_cast<whiteout_MdxMaterial*>(new whiteout::mdx::Material());
}

void whiteout_mdx_MdxMaterial_delete(whiteout_MdxMaterial* self) {
    delete reinterpret_cast<whiteout::mdx::Material*>(self);
}

int32_t whiteout_mdx_MdxMaterial_get_priorityPlane(const whiteout_MdxMaterial* self) {
    return reinterpret_cast<const whiteout::mdx::Material*>(self)->priorityPlane;
}

void whiteout_mdx_MdxMaterial_set_priorityPlane(whiteout_MdxMaterial* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Material*>(self)->priorityPlane = value;
}

int32_t whiteout_mdx_MdxMaterial_get_flags(const whiteout_MdxMaterial* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Material*>(self)->flags);
}

void whiteout_mdx_MdxMaterial_set_flags(whiteout_MdxMaterial* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Material*>(self)->flags = static_cast<whiteout::mdx::Material::Flag>(value);
}

whiteout_CString whiteout_mdx_MdxMaterial_get_shader(const whiteout_MdxMaterial* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Material*>(self)->shader);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxMaterial_set_shader(whiteout_MdxMaterial* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Material*>(self)->shader = (value ? value : "");
}

size_t whiteout_mdx_MdxMaterial_get_layers_count(const whiteout_MdxMaterial* self) {
    return reinterpret_cast<const whiteout::mdx::Material*>(self)->layers.size();
}

void whiteout_mdx_MdxMaterial_resize_layers(whiteout_MdxMaterial* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Material*>(self)->layers.resize(count);
}

whiteout_MdxLayer* whiteout_mdx_MdxMaterial_get_layers_at(whiteout_MdxMaterial* self, size_t index) {
    return reinterpret_cast<whiteout_MdxLayer*>(&reinterpret_cast<whiteout::mdx::Material*>(self)->layers[index]);
}

} // extern "C"

// ── MdxTextureAnimation ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTextureAnimation* whiteout_mdx_MdxTextureAnimation_new(void) {
    return reinterpret_cast<whiteout_MdxTextureAnimation*>(new whiteout::mdx::TextureAnimation());
}

void whiteout_mdx_MdxTextureAnimation_delete(whiteout_MdxTextureAnimation* self) {
    delete reinterpret_cast<whiteout::mdx::TextureAnimation*>(self);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxTextureAnimation_get_translationTracks(whiteout_MdxTextureAnimation* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->translationTracks);
}

void whiteout_mdx_MdxTextureAnimation_set_translationTracks(whiteout_MdxTextureAnimation* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->translationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackQuaternion* whiteout_mdx_MdxTextureAnimation_get_rotationTracks(whiteout_MdxTextureAnimation* self) {
    return reinterpret_cast<whiteout_MdxTrackQuaternion*>(&reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->rotationTracks);
}

void whiteout_mdx_MdxTextureAnimation_set_rotationTracks(whiteout_MdxTextureAnimation* self, const whiteout_MdxTrackQuaternion* value) {
    reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->rotationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxTextureAnimation_get_scalingTracks(whiteout_MdxTextureAnimation* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->scalingTracks);
}

void whiteout_mdx_MdxTextureAnimation_set_scalingTracks(whiteout_MdxTextureAnimation* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::TextureAnimation*>(self)->scalingTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

} // extern "C"

// ── MdxGeoset ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxGeoset* whiteout_mdx_MdxGeoset_new(void) {
    return reinterpret_cast<whiteout_MdxGeoset*>(new whiteout::mdx::Geoset());
}

void whiteout_mdx_MdxGeoset_delete(whiteout_MdxGeoset* self) {
    delete reinterpret_cast<whiteout::mdx::Geoset*>(self);
}

size_t whiteout_mdx_MdxGeoset_get_vertexPositions_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexPositions.size();
}

void whiteout_mdx_MdxGeoset_resize_vertexPositions(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->vertexPositions.resize(count);
}

const float* whiteout_mdx_MdxGeoset_get_vertexPositions_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexPositions;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

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

size_t whiteout_mdx_MdxGeoset_get_vertexNormals_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexNormals.size();
}

void whiteout_mdx_MdxGeoset_resize_vertexNormals(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->vertexNormals.resize(count);
}

const float* whiteout_mdx_MdxGeoset_get_vertexNormals_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexNormals;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_vertexNormals(whiteout_MdxGeoset* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->vertexNormals;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

size_t whiteout_mdx_MdxGeoset_get_faceTypeGroups_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faceTypeGroups.size();
}

void whiteout_mdx_MdxGeoset_resize_faceTypeGroups(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->faceTypeGroups.resize(count);
}

const uint32_t* whiteout_mdx_MdxGeoset_get_faceTypeGroups_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faceTypeGroups;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_faceTypeGroups(whiteout_MdxGeoset* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->faceTypeGroups;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_mdx_MdxGeoset_get_faceGroups_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faceGroups.size();
}

void whiteout_mdx_MdxGeoset_resize_faceGroups(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->faceGroups.resize(count);
}

const uint32_t* whiteout_mdx_MdxGeoset_get_faceGroups_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faceGroups;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_faceGroups(whiteout_MdxGeoset* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->faceGroups;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_mdx_MdxGeoset_get_faces_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faces.size();
}

void whiteout_mdx_MdxGeoset_resize_faces(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->faces.resize(count);
}

const uint16_t* whiteout_mdx_MdxGeoset_get_faces_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->faces;
    return __v.empty() ? nullptr : reinterpret_cast<const uint16_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_faces(whiteout_MdxGeoset* self, const uint16_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->faces;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u16));
}

size_t whiteout_mdx_MdxGeoset_get_vertexGroups_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexGroups.size();
}

void whiteout_mdx_MdxGeoset_resize_vertexGroups(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->vertexGroups.resize(count);
}

const uint8_t* whiteout_mdx_MdxGeoset_get_vertexGroups_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->vertexGroups;
    return __v.empty() ? nullptr : reinterpret_cast<const uint8_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_vertexGroups(whiteout_MdxGeoset* self, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->vertexGroups;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u8));
}

size_t whiteout_mdx_MdxGeoset_get_matrixGroups_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->matrixGroups.size();
}

void whiteout_mdx_MdxGeoset_resize_matrixGroups(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->matrixGroups.resize(count);
}

const uint32_t* whiteout_mdx_MdxGeoset_get_matrixGroups_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->matrixGroups;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_matrixGroups(whiteout_MdxGeoset* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->matrixGroups;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

size_t whiteout_mdx_MdxGeoset_get_matrixIndices_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->matrixIndices.size();
}

void whiteout_mdx_MdxGeoset_resize_matrixIndices(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->matrixIndices.resize(count);
}

const uint32_t* whiteout_mdx_MdxGeoset_get_matrixIndices_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->matrixIndices;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_matrixIndices(whiteout_MdxGeoset* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->matrixIndices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

uint32_t whiteout_mdx_MdxGeoset_get_materialId(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->materialId;
}

void whiteout_mdx_MdxGeoset_set_materialId(whiteout_MdxGeoset* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->materialId = value;
}

uint32_t whiteout_mdx_MdxGeoset_get_selectionGroup(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->selectionGroup;
}

void whiteout_mdx_MdxGeoset_set_selectionGroup(whiteout_MdxGeoset* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->selectionGroup = value;
}

uint32_t whiteout_mdx_MdxGeoset_get_selectionFlags(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->selectionFlags;
}

void whiteout_mdx_MdxGeoset_set_selectionFlags(whiteout_MdxGeoset* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->selectionFlags = value;
}

uint32_t whiteout_mdx_MdxGeoset_get_lod(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->lod;
}

void whiteout_mdx_MdxGeoset_set_lod(whiteout_MdxGeoset* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->lod = value;
}

whiteout_CString whiteout_mdx_MdxGeoset_get_lodName(const whiteout_MdxGeoset* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Geoset*>(self)->lodName);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxGeoset_set_lodName(whiteout_MdxGeoset* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->lodName = (value ? value : "");
}

whiteout_MdxExtent* whiteout_mdx_MdxGeoset_get_extent(whiteout_MdxGeoset* self) {
    return reinterpret_cast<whiteout_MdxExtent*>(&reinterpret_cast<whiteout::mdx::Geoset*>(self)->extent);
}

void whiteout_mdx_MdxGeoset_set_extent(whiteout_MdxGeoset* self, const whiteout_MdxExtent* value) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->extent = *reinterpret_cast<const whiteout::mdx::Extent*>(value);
}

size_t whiteout_mdx_MdxGeoset_get_sequenceExtents_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->sequenceExtents.size();
}

void whiteout_mdx_MdxGeoset_resize_sequenceExtents(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->sequenceExtents.resize(count);
}

whiteout_MdxExtent* whiteout_mdx_MdxGeoset_get_sequenceExtents_at(whiteout_MdxGeoset* self, size_t index) {
    return reinterpret_cast<whiteout_MdxExtent*>(&reinterpret_cast<whiteout::mdx::Geoset*>(self)->sequenceExtents[index]);
}

size_t whiteout_mdx_MdxGeoset_get_tangents_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->tangents.size();
}

void whiteout_mdx_MdxGeoset_resize_tangents(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->tangents.resize(count);
}

const float* whiteout_mdx_MdxGeoset_get_tangents_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->tangents;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_tangents(whiteout_MdxGeoset* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->tangents;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector4f));
}

size_t whiteout_mdx_MdxGeoset_get_skinData_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->skinData.size();
}

void whiteout_mdx_MdxGeoset_resize_skinData(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->skinData.resize(count);
}

const uint8_t* whiteout_mdx_MdxGeoset_get_skinData_data(const whiteout_MdxGeoset* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->skinData;
    return __v.empty() ? nullptr : reinterpret_cast<const uint8_t*>(__v.data());
}

void whiteout_mdx_MdxGeoset_assign_skinData(whiteout_MdxGeoset* self, const uint8_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->skinData;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u8));
}

size_t whiteout_mdx_MdxGeoset_get_textureCoordinateSets_count(const whiteout_MdxGeoset* self) {
    return reinterpret_cast<const whiteout::mdx::Geoset*>(self)->textureCoordinateSets.size();
}

size_t whiteout_mdx_MdxGeoset_get_textureCoordinateSets_inner_count(const whiteout_MdxGeoset* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->textureCoordinateSets;
    return outer_idx < __v.size() ? __v[outer_idx].size() : 0;
}

void whiteout_mdx_MdxGeoset_resize_textureCoordinateSets(whiteout_MdxGeoset* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Geoset*>(self)->textureCoordinateSets.resize(count);
}

void whiteout_mdx_MdxGeoset_resize_textureCoordinateSets_inner(whiteout_MdxGeoset* self, size_t outer_idx, size_t inner_count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->textureCoordinateSets;
    if (outer_idx < __v.size()) __v[outer_idx].resize(inner_count);
}

const float* whiteout_mdx_MdxGeoset_get_textureCoordinateSets_inner_data(const whiteout_MdxGeoset* self, size_t outer_idx) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Geoset*>(self)->textureCoordinateSets;
    if (outer_idx >= __v.size() || __v[outer_idx].empty()) return nullptr;
    return reinterpret_cast<const float*>(__v[outer_idx].data());
}

void whiteout_mdx_MdxGeoset_assign_textureCoordinateSets_inner(whiteout_MdxGeoset* self, size_t outer_idx, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Geoset*>(self)->textureCoordinateSets;
    if (outer_idx >= __v.size()) return;
    auto& __row = __v[outer_idx];
    __row.resize(count);
    if (count) std::memcpy(__row.data(), data, count * sizeof(whiteout::Vector2f));
}

} // extern "C"

// ── MdxGeosetAnimation ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxGeosetAnimation* whiteout_mdx_MdxGeosetAnimation_new(void) {
    return reinterpret_cast<whiteout_MdxGeosetAnimation*>(new whiteout::mdx::GeosetAnimation());
}

void whiteout_mdx_MdxGeosetAnimation_delete(whiteout_MdxGeosetAnimation* self) {
    delete reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self);
}

float whiteout_mdx_MdxGeosetAnimation_get_alpha(const whiteout_MdxGeosetAnimation* self) {
    return reinterpret_cast<const whiteout::mdx::GeosetAnimation*>(self)->alpha;
}

void whiteout_mdx_MdxGeosetAnimation_set_alpha(whiteout_MdxGeosetAnimation* self, float value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->alpha = value;
}

int32_t whiteout_mdx_MdxGeosetAnimation_get_flags(const whiteout_MdxGeosetAnimation* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::GeosetAnimation*>(self)->flags);
}

void whiteout_mdx_MdxGeosetAnimation_set_flags(whiteout_MdxGeosetAnimation* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->flags = static_cast<whiteout::mdx::GeosetAnimation::Flag>(value);
}

whiteout_Vector3f* whiteout_mdx_MdxGeosetAnimation_get_color(whiteout_MdxGeosetAnimation* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->color);
}

void whiteout_mdx_MdxGeosetAnimation_set_color(whiteout_MdxGeosetAnimation* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->color = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

uint32_t whiteout_mdx_MdxGeosetAnimation_get_geosetId(const whiteout_MdxGeosetAnimation* self) {
    return reinterpret_cast<const whiteout::mdx::GeosetAnimation*>(self)->geosetId;
}

void whiteout_mdx_MdxGeosetAnimation_set_geosetId(whiteout_MdxGeosetAnimation* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->geosetId = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxGeosetAnimation_get_alphaTracks(whiteout_MdxGeosetAnimation* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->alphaTracks);
}

void whiteout_mdx_MdxGeosetAnimation_set_alphaTracks(whiteout_MdxGeosetAnimation* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->alphaTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxGeosetAnimation_get_colorTracks(whiteout_MdxGeosetAnimation* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->colorTracks);
}

void whiteout_mdx_MdxGeosetAnimation_set_colorTracks(whiteout_MdxGeosetAnimation* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::GeosetAnimation*>(self)->colorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

} // extern "C"

// ── MdxBone ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxBone* whiteout_mdx_MdxBone_new(void) {
    return reinterpret_cast<whiteout_MdxBone*>(new whiteout::mdx::Bone());
}

void whiteout_mdx_MdxBone_delete(whiteout_MdxBone* self) {
    delete reinterpret_cast<whiteout::mdx::Bone*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxBone_get_node(whiteout_MdxBone* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::Bone*>(self)->node);
}

void whiteout_mdx_MdxBone_set_node(whiteout_MdxBone* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::Bone*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

uint32_t whiteout_mdx_MdxBone_get_geosetId(const whiteout_MdxBone* self) {
    return reinterpret_cast<const whiteout::mdx::Bone*>(self)->geosetId;
}

void whiteout_mdx_MdxBone_set_geosetId(whiteout_MdxBone* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Bone*>(self)->geosetId = value;
}

uint32_t whiteout_mdx_MdxBone_get_geosetAnimationId(const whiteout_MdxBone* self) {
    return reinterpret_cast<const whiteout::mdx::Bone*>(self)->geosetAnimationId;
}

void whiteout_mdx_MdxBone_set_geosetAnimationId(whiteout_MdxBone* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Bone*>(self)->geosetAnimationId = value;
}

} // extern "C"

// ── MdxLight ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxLight* whiteout_mdx_MdxLight_new(void) {
    return reinterpret_cast<whiteout_MdxLight*>(new whiteout::mdx::Light());
}

void whiteout_mdx_MdxLight_delete(whiteout_MdxLight* self) {
    delete reinterpret_cast<whiteout::mdx::Light*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxLight_get_node(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->node);
}

void whiteout_mdx_MdxLight_set_node(whiteout_MdxLight* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

int32_t whiteout_mdx_MdxLight_get_type(const whiteout_MdxLight* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Light*>(self)->type);
}

void whiteout_mdx_MdxLight_set_type(whiteout_MdxLight* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->type = static_cast<whiteout::mdx::Light::LightType>(value);
}

float whiteout_mdx_MdxLight_get_attenuationStart(const whiteout_MdxLight* self) {
    return reinterpret_cast<const whiteout::mdx::Light*>(self)->attenuationStart;
}

void whiteout_mdx_MdxLight_set_attenuationStart(whiteout_MdxLight* self, float value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationStart = value;
}

float whiteout_mdx_MdxLight_get_attenuationEnd(const whiteout_MdxLight* self) {
    return reinterpret_cast<const whiteout::mdx::Light*>(self)->attenuationEnd;
}

void whiteout_mdx_MdxLight_set_attenuationEnd(whiteout_MdxLight* self, float value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationEnd = value;
}

whiteout_Vector3f* whiteout_mdx_MdxLight_get_color(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->color);
}

void whiteout_mdx_MdxLight_set_color(whiteout_MdxLight* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->color = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxLight_get_intensity(const whiteout_MdxLight* self) {
    return reinterpret_cast<const whiteout::mdx::Light*>(self)->intensity;
}

void whiteout_mdx_MdxLight_set_intensity(whiteout_MdxLight* self, float value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->intensity = value;
}

whiteout_Vector3f* whiteout_mdx_MdxLight_get_ambientColor(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->ambientColor);
}

void whiteout_mdx_MdxLight_set_ambientColor(whiteout_MdxLight* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->ambientColor = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxLight_get_ambientIntensity(const whiteout_MdxLight* self) {
    return reinterpret_cast<const whiteout::mdx::Light*>(self)->ambientIntensity;
}

void whiteout_mdx_MdxLight_set_ambientIntensity(whiteout_MdxLight* self, float value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->ambientIntensity = value;
}

float whiteout_mdx_MdxLight_get_shadowIntensity(const whiteout_MdxLight* self) {
    return reinterpret_cast<const whiteout::mdx::Light*>(self)->shadowIntensity;
}

void whiteout_mdx_MdxLight_set_shadowIntensity(whiteout_MdxLight* self, float value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->shadowIntensity = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_attenuationStartTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationStartTracks);
}

void whiteout_mdx_MdxLight_set_attenuationStartTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationStartTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_attenuationEndTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationEndTracks);
}

void whiteout_mdx_MdxLight_set_attenuationEndTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->attenuationEndTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxLight_get_colorTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->colorTracks);
}

void whiteout_mdx_MdxLight_set_colorTracks(whiteout_MdxLight* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->colorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_intensityTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->intensityTracks);
}

void whiteout_mdx_MdxLight_set_intensityTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->intensityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_ambientIntensityTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->ambientIntensityTracks);
}

void whiteout_mdx_MdxLight_set_ambientIntensityTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->ambientIntensityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxLight_get_ambientColorTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->ambientColorTracks);
}

void whiteout_mdx_MdxLight_set_ambientColorTracks(whiteout_MdxLight* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->ambientColorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_visibilityTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxLight_set_visibilityTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxLight_get_shadowIntensityTracks(whiteout_MdxLight* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Light*>(self)->shadowIntensityTracks);
}

void whiteout_mdx_MdxLight_set_shadowIntensityTracks(whiteout_MdxLight* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Light*>(self)->shadowIntensityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxHelper ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxHelper* whiteout_mdx_MdxHelper_new(void) {
    return reinterpret_cast<whiteout_MdxHelper*>(new whiteout::mdx::Helper());
}

void whiteout_mdx_MdxHelper_delete(whiteout_MdxHelper* self) {
    delete reinterpret_cast<whiteout::mdx::Helper*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxHelper_get_node(whiteout_MdxHelper* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::Helper*>(self)->node);
}

void whiteout_mdx_MdxHelper_set_node(whiteout_MdxHelper* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::Helper*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

} // extern "C"

// ── MdxAttachment ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxAttachment* whiteout_mdx_MdxAttachment_new(void) {
    return reinterpret_cast<whiteout_MdxAttachment*>(new whiteout::mdx::Attachment());
}

void whiteout_mdx_MdxAttachment_delete(whiteout_MdxAttachment* self) {
    delete reinterpret_cast<whiteout::mdx::Attachment*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxAttachment_get_node(whiteout_MdxAttachment* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::Attachment*>(self)->node);
}

void whiteout_mdx_MdxAttachment_set_node(whiteout_MdxAttachment* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::Attachment*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

whiteout_CString whiteout_mdx_MdxAttachment_get_path(const whiteout_MdxAttachment* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Attachment*>(self)->path);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxAttachment_set_path(whiteout_MdxAttachment* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Attachment*>(self)->path = (value ? value : "");
}

uint32_t whiteout_mdx_MdxAttachment_get_attachmentId(const whiteout_MdxAttachment* self) {
    return reinterpret_cast<const whiteout::mdx::Attachment*>(self)->attachmentId;
}

void whiteout_mdx_MdxAttachment_set_attachmentId(whiteout_MdxAttachment* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Attachment*>(self)->attachmentId = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxAttachment_get_visibilityTracks(whiteout_MdxAttachment* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Attachment*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxAttachment_set_visibilityTracks(whiteout_MdxAttachment* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Attachment*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxParticleEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxParticleEmitter* whiteout_mdx_MdxParticleEmitter_new(void) {
    return reinterpret_cast<whiteout_MdxParticleEmitter*>(new whiteout::mdx::ParticleEmitter());
}

void whiteout_mdx_MdxParticleEmitter_delete(whiteout_MdxParticleEmitter* self) {
    delete reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxParticleEmitter_get_node(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->node);
}

void whiteout_mdx_MdxParticleEmitter_set_node(whiteout_MdxParticleEmitter* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

float whiteout_mdx_MdxParticleEmitter_get_emissionRate(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->emissionRate;
}

void whiteout_mdx_MdxParticleEmitter_set_emissionRate(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->emissionRate = value;
}

float whiteout_mdx_MdxParticleEmitter_get_gravity(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->gravity;
}

void whiteout_mdx_MdxParticleEmitter_set_gravity(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->gravity = value;
}

float whiteout_mdx_MdxParticleEmitter_get_longitude(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->longitude;
}

void whiteout_mdx_MdxParticleEmitter_set_longitude(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->longitude = value;
}

float whiteout_mdx_MdxParticleEmitter_get_latitude(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->latitude;
}

void whiteout_mdx_MdxParticleEmitter_set_latitude(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->latitude = value;
}

whiteout_CString whiteout_mdx_MdxParticleEmitter_get_spawnModelFileName(const whiteout_MdxParticleEmitter* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->spawnModelFileName);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxParticleEmitter_set_spawnModelFileName(whiteout_MdxParticleEmitter* self, const char* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->spawnModelFileName = (value ? value : "");
}

float whiteout_mdx_MdxParticleEmitter_get_lifespan(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->lifespan;
}

void whiteout_mdx_MdxParticleEmitter_set_lifespan(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->lifespan = value;
}

float whiteout_mdx_MdxParticleEmitter_get_initialVelocity(const whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter*>(self)->initialVelocity;
}

void whiteout_mdx_MdxParticleEmitter_set_initialVelocity(whiteout_MdxParticleEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->initialVelocity = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_emissionRateTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->emissionRateTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_emissionRateTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->emissionRateTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_gravityTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->gravityTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_gravityTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->gravityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_longitudeTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->longitudeTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_longitudeTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->longitudeTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_latitudeTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->latitudeTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_latitudeTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->latitudeTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_lifespanTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->lifespanTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_lifespanTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->lifespanTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_speedTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->speedTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_speedTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->speedTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter_get_visibilityTracks(whiteout_MdxParticleEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxParticleEmitter_set_visibilityTracks(whiteout_MdxParticleEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxParticleEmitter2 ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxParticleEmitter2* whiteout_mdx_MdxParticleEmitter2_new(void) {
    return reinterpret_cast<whiteout_MdxParticleEmitter2*>(new whiteout::mdx::ParticleEmitter2());
}

void whiteout_mdx_MdxParticleEmitter2_delete(whiteout_MdxParticleEmitter2* self) {
    delete reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxParticleEmitter2_get_node(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->node);
}

void whiteout_mdx_MdxParticleEmitter2_set_node(whiteout_MdxParticleEmitter2* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

float whiteout_mdx_MdxParticleEmitter2_get_speed(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->speed;
}

void whiteout_mdx_MdxParticleEmitter2_set_speed(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->speed = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_variation(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->variation;
}

void whiteout_mdx_MdxParticleEmitter2_set_variation(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->variation = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_latitude(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->latitude;
}

void whiteout_mdx_MdxParticleEmitter2_set_latitude(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->latitude = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_gravity(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->gravity;
}

void whiteout_mdx_MdxParticleEmitter2_set_gravity(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->gravity = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_lifespan(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->lifespan;
}

void whiteout_mdx_MdxParticleEmitter2_set_lifespan(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->lifespan = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_emissionRate(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->emissionRate;
}

void whiteout_mdx_MdxParticleEmitter2_set_emissionRate(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->emissionRate = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_length(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->length;
}

void whiteout_mdx_MdxParticleEmitter2_set_length(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->length = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_width(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->width;
}

void whiteout_mdx_MdxParticleEmitter2_set_width(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->width = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_filterMode(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->filterMode;
}

void whiteout_mdx_MdxParticleEmitter2_set_filterMode(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->filterMode = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_rows(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->rows;
}

void whiteout_mdx_MdxParticleEmitter2_set_rows(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->rows = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_columns(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->columns;
}

void whiteout_mdx_MdxParticleEmitter2_set_columns(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->columns = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_headOrTail(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->headOrTail;
}

void whiteout_mdx_MdxParticleEmitter2_set_headOrTail(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->headOrTail = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_tailLength(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->tailLength;
}

void whiteout_mdx_MdxParticleEmitter2_set_tailLength(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->tailLength = value;
}

float whiteout_mdx_MdxParticleEmitter2_get_time(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->time;
}

void whiteout_mdx_MdxParticleEmitter2_set_time(whiteout_MdxParticleEmitter2* self, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->time = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_segmentColor_size(void) {
    return 3;
}

whiteout_Vector3f* whiteout_mdx_MdxParticleEmitter2_get_segmentColor_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return const_cast<whiteout_Vector3f*>(reinterpret_cast<const whiteout_Vector3f*>(&reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->segmentColor[index]));
}

size_t whiteout_mdx_MdxParticleEmitter2_segmentAlpha_size(void) {
    return 3;
}

uint8_t whiteout_mdx_MdxParticleEmitter2_get_segmentAlpha_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->segmentAlpha[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_segmentAlpha_at(whiteout_MdxParticleEmitter2* self, size_t index, uint8_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->segmentAlpha[index] = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_segmentScaling_size(void) {
    return 3;
}

float whiteout_mdx_MdxParticleEmitter2_get_segmentScaling_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->segmentScaling[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_segmentScaling_at(whiteout_MdxParticleEmitter2* self, size_t index, float value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->segmentScaling[index] = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_headInterval_size(void) {
    return 3;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_headInterval_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->headInterval[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_headInterval_at(whiteout_MdxParticleEmitter2* self, size_t index, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->headInterval[index] = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_headDecayInterval_size(void) {
    return 3;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_headDecayInterval_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->headDecayInterval[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_headDecayInterval_at(whiteout_MdxParticleEmitter2* self, size_t index, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->headDecayInterval[index] = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_tailInterval_size(void) {
    return 3;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_tailInterval_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->tailInterval[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_tailInterval_at(whiteout_MdxParticleEmitter2* self, size_t index, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->tailInterval[index] = value;
}

size_t whiteout_mdx_MdxParticleEmitter2_tailDecayInterval_size(void) {
    return 3;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_tailDecayInterval_at(const whiteout_MdxParticleEmitter2* self, size_t index) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->tailDecayInterval[index];
}

void whiteout_mdx_MdxParticleEmitter2_set_tailDecayInterval_at(whiteout_MdxParticleEmitter2* self, size_t index, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->tailDecayInterval[index] = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_textureId(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->textureId;
}

void whiteout_mdx_MdxParticleEmitter2_set_textureId(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->textureId = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_squirt(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->squirt;
}

void whiteout_mdx_MdxParticleEmitter2_set_squirt(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->squirt = value;
}

int32_t whiteout_mdx_MdxParticleEmitter2_get_priorityPlane(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->priorityPlane;
}

void whiteout_mdx_MdxParticleEmitter2_set_priorityPlane(whiteout_MdxParticleEmitter2* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->priorityPlane = value;
}

uint32_t whiteout_mdx_MdxParticleEmitter2_get_replaceableId(const whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<const whiteout::mdx::ParticleEmitter2*>(self)->replaceableId;
}

void whiteout_mdx_MdxParticleEmitter2_set_replaceableId(whiteout_MdxParticleEmitter2* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->replaceableId = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_speedTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->speedTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_speedTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->speedTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_variationTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->variationTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_variationTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->variationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_latitudeTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->latitudeTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_latitudeTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->latitudeTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_gravityTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->gravityTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_gravityTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->gravityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_emissionRateTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->emissionRateTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_emissionRateTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->emissionRateTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_lengthTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->lengthTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_lengthTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->lengthTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_widthTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->widthTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_widthTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->widthTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxParticleEmitter2_get_visibilityTracks(whiteout_MdxParticleEmitter2* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxParticleEmitter2_set_visibilityTracks(whiteout_MdxParticleEmitter2* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::ParticleEmitter2*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxRibbonEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxRibbonEmitter* whiteout_mdx_MdxRibbonEmitter_new(void) {
    return reinterpret_cast<whiteout_MdxRibbonEmitter*>(new whiteout::mdx::RibbonEmitter());
}

void whiteout_mdx_MdxRibbonEmitter_delete(whiteout_MdxRibbonEmitter* self) {
    delete reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxRibbonEmitter_get_node(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->node);
}

void whiteout_mdx_MdxRibbonEmitter_set_node(whiteout_MdxRibbonEmitter* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

float whiteout_mdx_MdxRibbonEmitter_get_heightAbove(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->heightAbove;
}

void whiteout_mdx_MdxRibbonEmitter_set_heightAbove(whiteout_MdxRibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightAbove = value;
}

float whiteout_mdx_MdxRibbonEmitter_get_heightBelow(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->heightBelow;
}

void whiteout_mdx_MdxRibbonEmitter_set_heightBelow(whiteout_MdxRibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightBelow = value;
}

float whiteout_mdx_MdxRibbonEmitter_get_alpha(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->alpha;
}

void whiteout_mdx_MdxRibbonEmitter_set_alpha(whiteout_MdxRibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->alpha = value;
}

whiteout_Vector3f* whiteout_mdx_MdxRibbonEmitter_get_color(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->color);
}

void whiteout_mdx_MdxRibbonEmitter_set_color(whiteout_MdxRibbonEmitter* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->color = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxRibbonEmitter_get_lifespan(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->lifespan;
}

void whiteout_mdx_MdxRibbonEmitter_set_lifespan(whiteout_MdxRibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->lifespan = value;
}

uint32_t whiteout_mdx_MdxRibbonEmitter_get_textureSlot(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->textureSlot;
}

void whiteout_mdx_MdxRibbonEmitter_set_textureSlot(whiteout_MdxRibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->textureSlot = value;
}

uint32_t whiteout_mdx_MdxRibbonEmitter_get_emissionRate(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->emissionRate;
}

void whiteout_mdx_MdxRibbonEmitter_set_emissionRate(whiteout_MdxRibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->emissionRate = value;
}

uint32_t whiteout_mdx_MdxRibbonEmitter_get_rows(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->rows;
}

void whiteout_mdx_MdxRibbonEmitter_set_rows(whiteout_MdxRibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->rows = value;
}

uint32_t whiteout_mdx_MdxRibbonEmitter_get_columns(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->columns;
}

void whiteout_mdx_MdxRibbonEmitter_set_columns(whiteout_MdxRibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->columns = value;
}

uint32_t whiteout_mdx_MdxRibbonEmitter_get_materialId(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->materialId;
}

void whiteout_mdx_MdxRibbonEmitter_set_materialId(whiteout_MdxRibbonEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->materialId = value;
}

float whiteout_mdx_MdxRibbonEmitter_get_gravity(const whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::RibbonEmitter*>(self)->gravity;
}

void whiteout_mdx_MdxRibbonEmitter_set_gravity(whiteout_MdxRibbonEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->gravity = value;
}

whiteout_MdxTrackF32* whiteout_mdx_MdxRibbonEmitter_get_heightAboveTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightAboveTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_heightAboveTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightAboveTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxRibbonEmitter_get_heightBelowTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightBelowTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_heightBelowTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->heightBelowTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxRibbonEmitter_get_alphaTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->alphaTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_alphaTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->alphaTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxRibbonEmitter_get_colorTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->colorTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_colorTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->colorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackU32* whiteout_mdx_MdxRibbonEmitter_get_textureSlotTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackU32*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->textureSlotTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_textureSlotTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackU32* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->textureSlotTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxRibbonEmitter_get_visibilityTracks(whiteout_MdxRibbonEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxRibbonEmitter_set_visibilityTracks(whiteout_MdxRibbonEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::RibbonEmitter*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxEventObject ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxEventObject* whiteout_mdx_MdxEventObject_new(void) {
    return reinterpret_cast<whiteout_MdxEventObject*>(new whiteout::mdx::EventObject());
}

void whiteout_mdx_MdxEventObject_delete(whiteout_MdxEventObject* self) {
    delete reinterpret_cast<whiteout::mdx::EventObject*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxEventObject_get_node(whiteout_MdxEventObject* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::EventObject*>(self)->node);
}

void whiteout_mdx_MdxEventObject_set_node(whiteout_MdxEventObject* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::EventObject*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

uint32_t whiteout_mdx_MdxEventObject_get_globalSequenceId(const whiteout_MdxEventObject* self) {
    return reinterpret_cast<const whiteout::mdx::EventObject*>(self)->globalSequenceId;
}

void whiteout_mdx_MdxEventObject_set_globalSequenceId(whiteout_MdxEventObject* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::EventObject*>(self)->globalSequenceId = value;
}

size_t whiteout_mdx_MdxEventObject_get_eventTrackTimes_count(const whiteout_MdxEventObject* self) {
    return reinterpret_cast<const whiteout::mdx::EventObject*>(self)->eventTrackTimes.size();
}

void whiteout_mdx_MdxEventObject_resize_eventTrackTimes(whiteout_MdxEventObject* self, size_t count) {
    reinterpret_cast<whiteout::mdx::EventObject*>(self)->eventTrackTimes.resize(count);
}

const uint32_t* whiteout_mdx_MdxEventObject_get_eventTrackTimes_data(const whiteout_MdxEventObject* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::EventObject*>(self)->eventTrackTimes;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxEventObject_assign_eventTrackTimes(whiteout_MdxEventObject* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::EventObject*>(self)->eventTrackTimes;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

} // extern "C"

// ── MdxCamera ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxCamera* whiteout_mdx_MdxCamera_new(void) {
    return reinterpret_cast<whiteout_MdxCamera*>(new whiteout::mdx::Camera());
}

void whiteout_mdx_MdxCamera_delete(whiteout_MdxCamera* self) {
    delete reinterpret_cast<whiteout::mdx::Camera*>(self);
}

whiteout_CString whiteout_mdx_MdxCamera_get_name(const whiteout_MdxCamera* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::Camera*>(self)->name);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxCamera_set_name(whiteout_MdxCamera* self, const char* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->name = (value ? value : "");
}

whiteout_Vector3f* whiteout_mdx_MdxCamera_get_position(whiteout_MdxCamera* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Camera*>(self)->position);
}

void whiteout_mdx_MdxCamera_set_position(whiteout_MdxCamera* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->position = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxCamera_get_fieldOfView(const whiteout_MdxCamera* self) {
    return reinterpret_cast<const whiteout::mdx::Camera*>(self)->fieldOfView;
}

void whiteout_mdx_MdxCamera_set_fieldOfView(whiteout_MdxCamera* self, float value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->fieldOfView = value;
}

float whiteout_mdx_MdxCamera_get_farClippingPlane(const whiteout_MdxCamera* self) {
    return reinterpret_cast<const whiteout::mdx::Camera*>(self)->farClippingPlane;
}

void whiteout_mdx_MdxCamera_set_farClippingPlane(whiteout_MdxCamera* self, float value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->farClippingPlane = value;
}

float whiteout_mdx_MdxCamera_get_nearClippingPlane(const whiteout_MdxCamera* self) {
    return reinterpret_cast<const whiteout::mdx::Camera*>(self)->nearClippingPlane;
}

void whiteout_mdx_MdxCamera_set_nearClippingPlane(whiteout_MdxCamera* self, float value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->nearClippingPlane = value;
}

whiteout_Vector3f* whiteout_mdx_MdxCamera_get_targetPosition(whiteout_MdxCamera* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::Camera*>(self)->targetPosition);
}

void whiteout_mdx_MdxCamera_set_targetPosition(whiteout_MdxCamera* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->targetPosition = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxCamera_get_positionTracks(whiteout_MdxCamera* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Camera*>(self)->positionTracks);
}

void whiteout_mdx_MdxCamera_set_positionTracks(whiteout_MdxCamera* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->positionTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCamera_get_targetRotationTracks(whiteout_MdxCamera* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::Camera*>(self)->targetRotationTracks);
}

void whiteout_mdx_MdxCamera_set_targetRotationTracks(whiteout_MdxCamera* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->targetRotationTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxCamera_get_targetPositionTracks(whiteout_MdxCamera* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::Camera*>(self)->targetPositionTracks);
}

void whiteout_mdx_MdxCamera_set_targetPositionTracks(whiteout_MdxCamera* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::Camera*>(self)->targetPositionTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

} // extern "C"

// ── MdxCollisionShape ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxCollisionShape* whiteout_mdx_MdxCollisionShape_new(void) {
    return reinterpret_cast<whiteout_MdxCollisionShape*>(new whiteout::mdx::CollisionShape());
}

void whiteout_mdx_MdxCollisionShape_delete(whiteout_MdxCollisionShape* self) {
    delete reinterpret_cast<whiteout::mdx::CollisionShape*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxCollisionShape_get_node(whiteout_MdxCollisionShape* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->node);
}

void whiteout_mdx_MdxCollisionShape_set_node(whiteout_MdxCollisionShape* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

int32_t whiteout_mdx_MdxCollisionShape_get_type(const whiteout_MdxCollisionShape* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::CollisionShape*>(self)->type);
}

void whiteout_mdx_MdxCollisionShape_set_type(whiteout_MdxCollisionShape* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->type = static_cast<whiteout::mdx::CollisionShape::ShapeType>(value);
}

size_t whiteout_mdx_MdxCollisionShape_get_vertices_count(const whiteout_MdxCollisionShape* self) {
    return reinterpret_cast<const whiteout::mdx::CollisionShape*>(self)->vertices.size();
}

void whiteout_mdx_MdxCollisionShape_resize_vertices(whiteout_MdxCollisionShape* self, size_t count) {
    reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->vertices.resize(count);
}

const float* whiteout_mdx_MdxCollisionShape_get_vertices_data(const whiteout_MdxCollisionShape* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::CollisionShape*>(self)->vertices;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxCollisionShape_assign_vertices(whiteout_MdxCollisionShape* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->vertices;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

float whiteout_mdx_MdxCollisionShape_get_radius(const whiteout_MdxCollisionShape* self) {
    return reinterpret_cast<const whiteout::mdx::CollisionShape*>(self)->radius;
}

void whiteout_mdx_MdxCollisionShape_set_radius(whiteout_MdxCollisionShape* self, float value) {
    reinterpret_cast<whiteout::mdx::CollisionShape*>(self)->radius = value;
}

} // extern "C"

// ── MdxFaceEffect ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxFaceEffect* whiteout_mdx_MdxFaceEffect_new(void) {
    return reinterpret_cast<whiteout_MdxFaceEffect*>(new whiteout::mdx::FaceEffect());
}

void whiteout_mdx_MdxFaceEffect_delete(whiteout_MdxFaceEffect* self) {
    delete reinterpret_cast<whiteout::mdx::FaceEffect*>(self);
}

whiteout_CString whiteout_mdx_MdxFaceEffect_get_name(const whiteout_MdxFaceEffect* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::FaceEffect*>(self)->name);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxFaceEffect_set_name(whiteout_MdxFaceEffect* self, const char* value) {
    reinterpret_cast<whiteout::mdx::FaceEffect*>(self)->name = (value ? value : "");
}

whiteout_CString whiteout_mdx_MdxFaceEffect_get_path(const whiteout_MdxFaceEffect* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::FaceEffect*>(self)->path);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxFaceEffect_set_path(whiteout_MdxFaceEffect* self, const char* value) {
    reinterpret_cast<whiteout::mdx::FaceEffect*>(self)->path = (value ? value : "");
}

} // extern "C"

// ── MdxCornEmitter ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxCornEmitter* whiteout_mdx_MdxCornEmitter_new(void) {
    return reinterpret_cast<whiteout_MdxCornEmitter*>(new whiteout::mdx::CornEmitter());
}

void whiteout_mdx_MdxCornEmitter_delete(whiteout_MdxCornEmitter* self) {
    delete reinterpret_cast<whiteout::mdx::CornEmitter*>(self);
}

whiteout_MdxNode* whiteout_mdx_MdxCornEmitter_get_node(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxNode*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->node);
}

void whiteout_mdx_MdxCornEmitter_set_node(whiteout_MdxCornEmitter* self, const whiteout_MdxNode* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->node = *reinterpret_cast<const whiteout::mdx::Node*>(value);
}

float whiteout_mdx_MdxCornEmitter_get_lifeSpan(const whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->lifeSpan;
}

void whiteout_mdx_MdxCornEmitter_set_lifeSpan(whiteout_MdxCornEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->lifeSpan = value;
}

float whiteout_mdx_MdxCornEmitter_get_emissionRate(const whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->emissionRate;
}

void whiteout_mdx_MdxCornEmitter_set_emissionRate(whiteout_MdxCornEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->emissionRate = value;
}

float whiteout_mdx_MdxCornEmitter_get_speed(const whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->speed;
}

void whiteout_mdx_MdxCornEmitter_set_speed(whiteout_MdxCornEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->speed = value;
}

whiteout_Vector3f* whiteout_mdx_MdxCornEmitter_get_color(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_Vector3f*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->color);
}

void whiteout_mdx_MdxCornEmitter_set_color(whiteout_MdxCornEmitter* self, const whiteout_Vector3f* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->color = *reinterpret_cast<const whiteout::Vector3f*>(value);
}

float whiteout_mdx_MdxCornEmitter_get_alpha(const whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->alpha;
}

void whiteout_mdx_MdxCornEmitter_set_alpha(whiteout_MdxCornEmitter* self, float value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->alpha = value;
}

uint32_t whiteout_mdx_MdxCornEmitter_get_replaceableId(const whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->replaceableId;
}

void whiteout_mdx_MdxCornEmitter_set_replaceableId(whiteout_MdxCornEmitter* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->replaceableId = value;
}

whiteout_CString whiteout_mdx_MdxCornEmitter_get_path(const whiteout_MdxCornEmitter* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->path);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxCornEmitter_set_path(whiteout_MdxCornEmitter* self, const char* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->path = (value ? value : "");
}

whiteout_CString whiteout_mdx_MdxCornEmitter_get_animVisibilityGuide(const whiteout_MdxCornEmitter* self) {
    auto* __owned = new std::string(reinterpret_cast<const whiteout::mdx::CornEmitter*>(self)->animVisibilityGuide);
    return whiteout_CString{ __owned->c_str(), __owned->size(), __owned };
}

void whiteout_mdx_MdxCornEmitter_set_animVisibilityGuide(whiteout_MdxCornEmitter* self, const char* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->animVisibilityGuide = (value ? value : "");
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCornEmitter_get_lifeSpanTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->lifeSpanTracks);
}

void whiteout_mdx_MdxCornEmitter_set_lifeSpanTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->lifeSpanTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCornEmitter_get_emissionRateTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->emissionRateTracks);
}

void whiteout_mdx_MdxCornEmitter_set_emissionRateTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->emissionRateTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCornEmitter_get_speedTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->speedTracks);
}

void whiteout_mdx_MdxCornEmitter_set_speedTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->speedTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackVector3f* whiteout_mdx_MdxCornEmitter_get_colorTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->colorTracks);
}

void whiteout_mdx_MdxCornEmitter_set_colorTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackVector3f* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->colorTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCornEmitter_get_alphaTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->alphaTracks);
}

void whiteout_mdx_MdxCornEmitter_set_alphaTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->alphaTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

whiteout_MdxTrackF32* whiteout_mdx_MdxCornEmitter_get_visibilityTracks(whiteout_MdxCornEmitter* self) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(&reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->visibilityTracks);
}

void whiteout_mdx_MdxCornEmitter_set_visibilityTracks(whiteout_MdxCornEmitter* self, const whiteout_MdxTrackF32* value) {
    reinterpret_cast<whiteout::mdx::CornEmitter*>(self)->visibilityTracks = *reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(value);
}

} // extern "C"

// ── MdxParser ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxParser* whiteout_mdx_MdxParser_new(void) {
    return reinterpret_cast<whiteout_MdxParser*>(new whiteout::mdx::Parser());
}

whiteout_MdxParser* whiteout_mdx_MdxParser_new_upgradeMode(int32_t upgradeMode) {
    return reinterpret_cast<whiteout_MdxParser*>(new whiteout::mdx::Parser(static_cast<whiteout::mdx::Parser::UpgradeMode>(upgradeMode)));
}

void whiteout_mdx_MdxParser_delete(whiteout_MdxParser* self) {
    delete reinterpret_cast<whiteout::mdx::Parser*>(self);
}

struct whiteout_MdxModel* whiteout_mdx_MdxParser_parse(whiteout_MdxParser* self, const char* filePath) {
    return reinterpret_cast<struct whiteout_MdxModel*>(
        new whiteout::mdx::Model(reinterpret_cast<whiteout::mdx::Parser*>(self)->parse(std::string(filePath ? filePath : ""))));
}

struct whiteout_MdxModel* whiteout_mdx_MdxParser_parse_buffer_format(whiteout_MdxParser* self, const uint8_t* buffer, size_t buffer_size, int32_t format) {
    return reinterpret_cast<struct whiteout_MdxModel*>(
        new whiteout::mdx::Model(reinterpret_cast<whiteout::mdx::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size), static_cast<whiteout::mdx::MDLXFormat>(format))));
}

int32_t whiteout_mdx_MdxParser_hasIssues(const whiteout_MdxParser* self) {
    return reinterpret_cast<const whiteout::mdx::Parser*>(self)->hasIssues();
}

size_t whiteout_mdx_MdxParser_getIssues_count(const whiteout_MdxParser* self) {
    return reinterpret_cast<const whiteout::mdx::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── MdxWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxWriter* whiteout_mdx_MdxWriter_new(void) {
    return reinterpret_cast<whiteout_MdxWriter*>(new whiteout::mdx::Writer());
}

void whiteout_mdx_MdxWriter_delete(whiteout_MdxWriter* self) {
    delete reinterpret_cast<whiteout::mdx::Writer*>(self);
}

void whiteout_mdx_MdxWriter_write(whiteout_MdxWriter* self, const char* filePath, struct whiteout_MdxModel* mdlx, int32_t mdlFormat) {
    reinterpret_cast<whiteout::mdx::Writer*>(self)->write(std::string(filePath ? filePath : ""), *reinterpret_cast<const whiteout::mdx::Model*>(mdlx), static_cast<whiteout::mdx::MdlFormat>(mdlFormat));
}

whiteout_Bytes whiteout_mdx_MdxWriter_write_mdx_format_mdlFormat(whiteout_MdxWriter* self, struct whiteout_MdxModel* mdx, int32_t format, int32_t mdlFormat) {
    return wrapBytes(reinterpret_cast<whiteout::mdx::Writer*>(self)->write(*reinterpret_cast<const whiteout::mdx::Model*>(mdx), static_cast<whiteout::mdx::MDLXFormat>(format), static_cast<whiteout::mdx::MdlFormat>(mdlFormat)));
}

} // extern "C"

// ── MdxTrackVector3f ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTrackVector3f* whiteout_mdx_MdxTrackVector3f_new(void) {
    return reinterpret_cast<whiteout_MdxTrackVector3f*>(new whiteout::mdx::Track<whiteout::Vector3f>());
}

void whiteout_mdx_MdxTrackVector3f_delete(whiteout_MdxTrackVector3f* self) {
    delete reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self);
}

int32_t whiteout_mdx_MdxTrackVector3f_get_isUsed(const whiteout_MdxTrackVector3f* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->isUsed;
}

void whiteout_mdx_MdxTrackVector3f_set_isUsed(whiteout_MdxTrackVector3f* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->isUsed = value;
}

int32_t whiteout_mdx_MdxTrackVector3f_get_interpolationType(const whiteout_MdxTrackVector3f* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->interpolationType);
}

void whiteout_mdx_MdxTrackVector3f_set_interpolationType(whiteout_MdxTrackVector3f* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->interpolationType = static_cast<whiteout::mdx::InterpolationType>(value);
}

uint32_t whiteout_mdx_MdxTrackVector3f_get_globalSequenceId(const whiteout_MdxTrackVector3f* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->globalSequenceId;
}

void whiteout_mdx_MdxTrackVector3f_set_globalSequenceId(whiteout_MdxTrackVector3f* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->globalSequenceId = value;
}

uint64_t whiteout_mdx_MdxTrackVector3f_get_keyCount(const whiteout_MdxTrackVector3f* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keyCount;
}

void whiteout_mdx_MdxTrackVector3f_set_keyCount(whiteout_MdxTrackVector3f* self, uint64_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keyCount = value;
}

size_t whiteout_mdx_MdxTrackVector3f_get_timestamps_count(const whiteout_MdxTrackVector3f* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->timestamps.size();
}

void whiteout_mdx_MdxTrackVector3f_resize_timestamps(whiteout_MdxTrackVector3f* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->timestamps.resize(count);
}

const uint32_t* whiteout_mdx_MdxTrackVector3f_get_timestamps_data(const whiteout_MdxTrackVector3f* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->timestamps;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxTrackVector3f_assign_timestamps(whiteout_MdxTrackVector3f* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->timestamps;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(u32));
}

size_t whiteout_mdx_MdxTrackVector3f_get_keys_count(const whiteout_MdxTrackVector3f* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keys_data.size();
}

void whiteout_mdx_MdxTrackVector3f_resize_keys(whiteout_MdxTrackVector3f* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keys_data.resize(count);
}

const float* whiteout_mdx_MdxTrackVector3f_get_keys_data(const whiteout_MdxTrackVector3f* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keys_data;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxTrackVector3f_assign_keys(whiteout_MdxTrackVector3f* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::Vector3f>*>(self)->keys_data;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Vector3f));
}

} // extern "C"

// ── MdxTrackQuaternion ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTrackQuaternion* whiteout_mdx_MdxTrackQuaternion_new(void) {
    return reinterpret_cast<whiteout_MdxTrackQuaternion*>(new whiteout::mdx::Track<whiteout::Quaternion>());
}

void whiteout_mdx_MdxTrackQuaternion_delete(whiteout_MdxTrackQuaternion* self) {
    delete reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self);
}

int32_t whiteout_mdx_MdxTrackQuaternion_get_isUsed(const whiteout_MdxTrackQuaternion* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->isUsed;
}

void whiteout_mdx_MdxTrackQuaternion_set_isUsed(whiteout_MdxTrackQuaternion* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->isUsed = value;
}

int32_t whiteout_mdx_MdxTrackQuaternion_get_interpolationType(const whiteout_MdxTrackQuaternion* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->interpolationType);
}

void whiteout_mdx_MdxTrackQuaternion_set_interpolationType(whiteout_MdxTrackQuaternion* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->interpolationType = static_cast<whiteout::mdx::InterpolationType>(value);
}

uint32_t whiteout_mdx_MdxTrackQuaternion_get_globalSequenceId(const whiteout_MdxTrackQuaternion* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->globalSequenceId;
}

void whiteout_mdx_MdxTrackQuaternion_set_globalSequenceId(whiteout_MdxTrackQuaternion* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->globalSequenceId = value;
}

uint64_t whiteout_mdx_MdxTrackQuaternion_get_keyCount(const whiteout_MdxTrackQuaternion* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keyCount;
}

void whiteout_mdx_MdxTrackQuaternion_set_keyCount(whiteout_MdxTrackQuaternion* self, uint64_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keyCount = value;
}

size_t whiteout_mdx_MdxTrackQuaternion_get_timestamps_count(const whiteout_MdxTrackQuaternion* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->timestamps.size();
}

void whiteout_mdx_MdxTrackQuaternion_resize_timestamps(whiteout_MdxTrackQuaternion* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->timestamps.resize(count);
}

const uint32_t* whiteout_mdx_MdxTrackQuaternion_get_timestamps_data(const whiteout_MdxTrackQuaternion* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->timestamps;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxTrackQuaternion_assign_timestamps(whiteout_MdxTrackQuaternion* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->timestamps;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(u32));
}

size_t whiteout_mdx_MdxTrackQuaternion_get_keys_count(const whiteout_MdxTrackQuaternion* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keys_data.size();
}

void whiteout_mdx_MdxTrackQuaternion_resize_keys(whiteout_MdxTrackQuaternion* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keys_data.resize(count);
}

const float* whiteout_mdx_MdxTrackQuaternion_get_keys_data(const whiteout_MdxTrackQuaternion* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keys_data;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxTrackQuaternion_assign_keys(whiteout_MdxTrackQuaternion* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::Quaternion>*>(self)->keys_data;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::Quaternion));
}

} // extern "C"

// ── MdxTrackU32 ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTrackU32* whiteout_mdx_MdxTrackU32_new(void) {
    return reinterpret_cast<whiteout_MdxTrackU32*>(new whiteout::mdx::Track<whiteout::u32>());
}

void whiteout_mdx_MdxTrackU32_delete(whiteout_MdxTrackU32* self) {
    delete reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self);
}

int32_t whiteout_mdx_MdxTrackU32_get_isUsed(const whiteout_MdxTrackU32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->isUsed;
}

void whiteout_mdx_MdxTrackU32_set_isUsed(whiteout_MdxTrackU32* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->isUsed = value;
}

int32_t whiteout_mdx_MdxTrackU32_get_interpolationType(const whiteout_MdxTrackU32* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->interpolationType);
}

void whiteout_mdx_MdxTrackU32_set_interpolationType(whiteout_MdxTrackU32* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->interpolationType = static_cast<whiteout::mdx::InterpolationType>(value);
}

uint32_t whiteout_mdx_MdxTrackU32_get_globalSequenceId(const whiteout_MdxTrackU32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->globalSequenceId;
}

void whiteout_mdx_MdxTrackU32_set_globalSequenceId(whiteout_MdxTrackU32* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->globalSequenceId = value;
}

uint64_t whiteout_mdx_MdxTrackU32_get_keyCount(const whiteout_MdxTrackU32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->keyCount;
}

void whiteout_mdx_MdxTrackU32_set_keyCount(whiteout_MdxTrackU32* self, uint64_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->keyCount = value;
}

size_t whiteout_mdx_MdxTrackU32_get_timestamps_count(const whiteout_MdxTrackU32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->timestamps.size();
}

void whiteout_mdx_MdxTrackU32_resize_timestamps(whiteout_MdxTrackU32* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->timestamps.resize(count);
}

const uint32_t* whiteout_mdx_MdxTrackU32_get_timestamps_data(const whiteout_MdxTrackU32* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->timestamps;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxTrackU32_assign_timestamps(whiteout_MdxTrackU32* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->timestamps;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(u32));
}

size_t whiteout_mdx_MdxTrackU32_get_keys_count(const whiteout_MdxTrackU32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->keys_data.size();
}

void whiteout_mdx_MdxTrackU32_resize_keys(whiteout_MdxTrackU32* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->keys_data.resize(count);
}

const uint32_t* whiteout_mdx_MdxTrackU32_get_keys_data(const whiteout_MdxTrackU32* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::u32>*>(self)->keys_data;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxTrackU32_assign_keys(whiteout_MdxTrackU32* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::u32>*>(self)->keys_data;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::u32));
}

} // extern "C"

// ── MdxTrackF32 ─────────────────────────────────────────────────

extern "C" {

whiteout_MdxTrackF32* whiteout_mdx_MdxTrackF32_new(void) {
    return reinterpret_cast<whiteout_MdxTrackF32*>(new whiteout::mdx::Track<whiteout::f32>());
}

void whiteout_mdx_MdxTrackF32_delete(whiteout_MdxTrackF32* self) {
    delete reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self);
}

int32_t whiteout_mdx_MdxTrackF32_get_isUsed(const whiteout_MdxTrackF32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->isUsed;
}

void whiteout_mdx_MdxTrackF32_set_isUsed(whiteout_MdxTrackF32* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->isUsed = value;
}

int32_t whiteout_mdx_MdxTrackF32_get_interpolationType(const whiteout_MdxTrackF32* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->interpolationType);
}

void whiteout_mdx_MdxTrackF32_set_interpolationType(whiteout_MdxTrackF32* self, int32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->interpolationType = static_cast<whiteout::mdx::InterpolationType>(value);
}

uint32_t whiteout_mdx_MdxTrackF32_get_globalSequenceId(const whiteout_MdxTrackF32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->globalSequenceId;
}

void whiteout_mdx_MdxTrackF32_set_globalSequenceId(whiteout_MdxTrackF32* self, uint32_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->globalSequenceId = value;
}

uint64_t whiteout_mdx_MdxTrackF32_get_keyCount(const whiteout_MdxTrackF32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->keyCount;
}

void whiteout_mdx_MdxTrackF32_set_keyCount(whiteout_MdxTrackF32* self, uint64_t value) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->keyCount = value;
}

size_t whiteout_mdx_MdxTrackF32_get_timestamps_count(const whiteout_MdxTrackF32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->timestamps.size();
}

void whiteout_mdx_MdxTrackF32_resize_timestamps(whiteout_MdxTrackF32* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->timestamps.resize(count);
}

const uint32_t* whiteout_mdx_MdxTrackF32_get_timestamps_data(const whiteout_MdxTrackF32* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->timestamps;
    return __v.empty() ? nullptr : reinterpret_cast<const uint32_t*>(__v.data());
}

void whiteout_mdx_MdxTrackF32_assign_timestamps(whiteout_MdxTrackF32* self, const uint32_t* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->timestamps;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(u32));
}

size_t whiteout_mdx_MdxTrackF32_get_keys_count(const whiteout_MdxTrackF32* self) {
    return reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->keys_data.size();
}

void whiteout_mdx_MdxTrackF32_resize_keys(whiteout_MdxTrackF32* self, size_t count) {
    reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->keys_data.resize(count);
}

const float* whiteout_mdx_MdxTrackF32_get_keys_data(const whiteout_MdxTrackF32* self) {
    const auto& __v = reinterpret_cast<const whiteout::mdx::Track<whiteout::f32>*>(self)->keys_data;
    return __v.empty() ? nullptr : reinterpret_cast<const float*>(__v.data());
}

void whiteout_mdx_MdxTrackF32_assign_keys(whiteout_MdxTrackF32* self, const float* data, size_t count) {
    auto& __v = reinterpret_cast<whiteout::mdx::Track<whiteout::f32>*>(self)->keys_data;
    __v.resize(count);
    if (count) std::memcpy(__v.data(), data, count * sizeof(whiteout::f32));
}

} // extern "C"