whiteoutlib 0.1.3

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

#include "whiteout_textures.h"

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

#include <whiteout/common_types.h>
#include <whiteout/textures/texture.h>
#include <whiteout/textures/blp/parser.h>
#include <whiteout/textures/blp/writer.h>
#include <whiteout/textures/png/parser.h>
#include <whiteout/textures/png/writer.h>
#include <whiteout/textures/jpeg/parser.h>
#include <whiteout/textures/jpeg/writer.h>
#include <whiteout/textures/dds/parser.h>
#include <whiteout/textures/dds/writer.h>
#include <whiteout/textures/bmp/parser.h>
#include <whiteout/textures/bmp/writer.h>
#include <whiteout/textures/tga/parser.h>
#include <whiteout/textures/tga/writer.h>
#include <whiteout/textures/tiff/parser.h>
#include <whiteout/textures/tiff/writer.h>
#include <whiteout/textures/gif/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

size_t whiteout_textures_TextureList_size(const whiteout_TextureList* self) {
    return reinterpret_cast<const std::vector<whiteout::textures::Texture>*>(self)->size();
}

struct whiteout_Texture* whiteout_textures_TextureList_at(whiteout_TextureList* self, size_t index) {
    auto* v = reinterpret_cast<std::vector<whiteout::textures::Texture>*>(self);
    return reinterpret_cast<struct whiteout_Texture*>(&(*v)[index]);
}

void whiteout_textures_TextureList_delete(whiteout_TextureList* self) {
    delete reinterpret_cast<std::vector<whiteout::textures::Texture>*>(self);
}
// ── MipLevel ─────────────────────────────────────────────────

extern "C" {

whiteout_MipLevel* whiteout_textures_MipLevel_new(void) {
    return reinterpret_cast<whiteout_MipLevel*>(new whiteout::textures::MipLevel());
}

void whiteout_textures_MipLevel_delete(whiteout_MipLevel* self) {
    delete reinterpret_cast<whiteout::textures::MipLevel*>(self);
}

uint32_t whiteout_textures_MipLevel_get_width(const whiteout_MipLevel* self) {
    return reinterpret_cast<const whiteout::textures::MipLevel*>(self)->width;
}

void whiteout_textures_MipLevel_set_width(whiteout_MipLevel* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::MipLevel*>(self)->width = value;
}

uint32_t whiteout_textures_MipLevel_get_height(const whiteout_MipLevel* self) {
    return reinterpret_cast<const whiteout::textures::MipLevel*>(self)->height;
}

void whiteout_textures_MipLevel_set_height(whiteout_MipLevel* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::MipLevel*>(self)->height = value;
}

uint32_t whiteout_textures_MipLevel_get_depth(const whiteout_MipLevel* self) {
    return reinterpret_cast<const whiteout::textures::MipLevel*>(self)->depth;
}

void whiteout_textures_MipLevel_set_depth(whiteout_MipLevel* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::MipLevel*>(self)->depth = value;
}

uint64_t whiteout_textures_MipLevel_get_offset(const whiteout_MipLevel* self) {
    return reinterpret_cast<const whiteout::textures::MipLevel*>(self)->offset;
}

void whiteout_textures_MipLevel_set_offset(whiteout_MipLevel* self, uint64_t value) {
    reinterpret_cast<whiteout::textures::MipLevel*>(self)->offset = value;
}

uint64_t whiteout_textures_MipLevel_get_size(const whiteout_MipLevel* self) {
    return reinterpret_cast<const whiteout::textures::MipLevel*>(self)->size;
}

void whiteout_textures_MipLevel_set_size(whiteout_MipLevel* self, uint64_t value) {
    reinterpret_cast<whiteout::textures::MipLevel*>(self)->size = value;
}

} // extern "C"

// ── Texture ─────────────────────────────────────────────────

extern "C" {

whiteout_Texture* whiteout_textures_Texture_new(void) {
    return reinterpret_cast<whiteout_Texture*>(new whiteout::textures::Texture());
}

void whiteout_textures_Texture_delete(whiteout_Texture* self) {
    delete reinterpret_cast<whiteout::textures::Texture*>(self);
}

void whiteout_textures_Texture_format(whiteout_Texture* self, int32_t new_fmt) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->format(static_cast<whiteout::textures::PixelFormat>(new_fmt));
}

int32_t whiteout_textures_Texture_format_overload2(const whiteout_Texture* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::textures::Texture*>(self)->format());
}

struct whiteout_Texture* whiteout_textures_Texture_copyAsFormat(const whiteout_Texture* self, int32_t new_fmt, void* pool) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(reinterpret_cast<const whiteout::textures::Texture*>(self)->copyAsFormat(static_cast<whiteout::textures::PixelFormat>(new_fmt), reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool))));
}

int32_t whiteout_textures_Texture_swapChannels(whiteout_Texture* self, int32_t a, int32_t b) {
    return reinterpret_cast<whiteout::textures::Texture*>(self)->swapChannels(static_cast<whiteout::textures::Channel>(a), static_cast<whiteout::textures::Channel>(b));
}

int32_t whiteout_textures_Texture_invertChannel(whiteout_Texture* self, int32_t ch) {
    return reinterpret_cast<whiteout::textures::Texture*>(self)->invertChannel(static_cast<whiteout::textures::Channel>(ch));
}

int32_t whiteout_textures_Texture_expandNormal(whiteout_Texture* self, int32_t xChannel, int32_t yChannel, int32_t zChannel) {
    return reinterpret_cast<whiteout::textures::Texture*>(self)->expandNormal(static_cast<whiteout::textures::Channel>(xChannel), static_cast<whiteout::textures::Channel>(yChannel), static_cast<whiteout::textures::Channel>(zChannel));
}

int32_t whiteout_textures_Texture_fillChannel(whiteout_Texture* self, int32_t target, float value) {
    return reinterpret_cast<whiteout::textures::Texture*>(self)->fillChannel(static_cast<whiteout::textures::Channel>(target), value);
}

struct whiteout_TextureList* whiteout_textures_Texture_splitChannels(const whiteout_Texture* self, const int32_t* channels, size_t channels_size) {
    auto __r = reinterpret_cast<const whiteout::textures::Texture*>(self)->splitChannels(([&]{ std::vector<whiteout::textures::Channel> __v; __v.reserve(channels_size); for (size_t __i = 0; __i < channels_size; ++__i) __v.push_back(static_cast<whiteout::textures::Channel>(channels[__i])); return __v; })());
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_TextureList*>(
        new std::vector<whiteout::textures::Texture>(std::move(*__r)));
}

struct whiteout_Texture* whiteout_textures_Texture_mergeChannels(const struct whiteout_Texture* const* sources, size_t sources_size, const int32_t* targetChannels, size_t targetChannels_size) {
    auto __r = whiteout::textures::Texture::mergeChannels(([&]{ std::vector<whiteout::textures::Texture> __v; __v.reserve(sources_size); for (size_t __i = 0; __i < sources_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::Texture*>(sources[__i])); return __v; })(), ([&]{ std::vector<whiteout::textures::Channel> __v; __v.reserve(targetChannels_size); for (size_t __i = 0; __i < targetChannels_size; ++__i) __v.push_back(static_cast<whiteout::textures::Channel>(targetChannels[__i])); return __v; })());
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

struct whiteout_Texture* whiteout_textures_Texture_copyFromNormalToRGBA(const whiteout_Texture* self, void* pool) {
    auto __r = reinterpret_cast<const whiteout::textures::Texture*>(self)->copyFromNormalToRGBA(reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

whiteout_CString whiteout_textures_Texture_generateMipmaps(whiteout_Texture* self, uint32_t newMipCount, void* pool) {
    auto __r = reinterpret_cast<whiteout::textures::Texture*>(self)->generateMipmaps(newMipCount, reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool));
    if (!__r) return emptyCString();
    return wrapCString(std::move(*__r));
}

whiteout_CString whiteout_textures_Texture_generateMipmaps_pool(whiteout_Texture* self, void* pool) {
    auto __r = reinterpret_cast<whiteout::textures::Texture*>(self)->generateMipmaps(reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool));
    if (!__r) return emptyCString();
    return wrapCString(std::move(*__r));
}

whiteout_CString whiteout_textures_Texture_downscale(whiteout_Texture* self, uint32_t levels, void* pool) {
    auto __r = reinterpret_cast<whiteout::textures::Texture*>(self)->downscale(levels, reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool));
    if (!__r) return emptyCString();
    return wrapCString(std::move(*__r));
}

struct whiteout_Texture* whiteout_textures_Texture_create2D(int32_t fmt, uint32_t width, uint32_t height, uint32_t mipCount) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(whiteout::textures::Texture::create2D(static_cast<whiteout::textures::PixelFormat>(fmt), width, height, mipCount)));
}

struct whiteout_Texture* whiteout_textures_Texture_create3D(int32_t fmt, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipCount) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(whiteout::textures::Texture::create3D(static_cast<whiteout::textures::PixelFormat>(fmt), width, height, depth, mipCount)));
}

struct whiteout_Texture* whiteout_textures_Texture_createCube(int32_t fmt, uint32_t size, uint32_t mipCount) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(whiteout::textures::Texture::createCube(static_cast<whiteout::textures::PixelFormat>(fmt), size, mipCount)));
}

struct whiteout_Texture* whiteout_textures_Texture_create2DArray(int32_t fmt, uint32_t width, uint32_t height, uint32_t arraySize, uint32_t mipCount) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(whiteout::textures::Texture::create2DArray(static_cast<whiteout::textures::PixelFormat>(fmt), width, height, arraySize, mipCount)));
}

struct whiteout_Texture* whiteout_textures_Texture_createCubeArray(int32_t fmt, uint32_t size, uint32_t arraySize, uint32_t mipCount) {
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(whiteout::textures::Texture::createCubeArray(static_cast<whiteout::textures::PixelFormat>(fmt), size, arraySize, mipCount)));
}

int32_t whiteout_textures_Texture_type(const whiteout_Texture* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::textures::Texture*>(self)->type());
}

int32_t whiteout_textures_Texture_kind(const whiteout_Texture* self) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::textures::Texture*>(self)->kind());
}

void whiteout_textures_Texture_setKind(whiteout_Texture* self, int32_t k) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->setKind(static_cast<whiteout::textures::TextureKind>(k));
}

int32_t whiteout_textures_Texture_channelKind(const whiteout_Texture* self, int32_t ch) {
    return static_cast<int32_t>(reinterpret_cast<const whiteout::textures::Texture*>(self)->channelKind(static_cast<whiteout::textures::Channel>(ch)));
}

void whiteout_textures_Texture_setChannelKind(whiteout_Texture* self, int32_t ch, int32_t kind) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->setChannelKind(static_cast<whiteout::textures::Channel>(ch), static_cast<whiteout::textures::TextureKind>(kind));
}

float whiteout_textures_Texture_channelDefault(const whiteout_Texture* self, int32_t ch) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->channelDefault(static_cast<whiteout::textures::Channel>(ch));
}

void whiteout_textures_Texture_setChannelDefault(whiteout_Texture* self, int32_t ch, float value) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->setChannelDefault(static_cast<whiteout::textures::Channel>(ch), value);
}

int32_t whiteout_textures_Texture_isSrgb(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->isSrgb();
}

void whiteout_textures_Texture_setSrgb(whiteout_Texture* self, int32_t srgb) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->setSrgb(srgb);
}

uint32_t whiteout_textures_Texture_width(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->width();
}

uint32_t whiteout_textures_Texture_height(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->height();
}

uint32_t whiteout_textures_Texture_depth(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->depth();
}

uint32_t whiteout_textures_Texture_layerCount(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->layerCount();
}

uint32_t whiteout_textures_Texture_arraySize(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->arraySize();
}

uint32_t whiteout_textures_Texture_mipCount(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->mipCount();
}

struct whiteout_MipLevel* whiteout_textures_Texture_mipLevel(const whiteout_Texture* self, uint32_t mip, uint32_t layer) {
    auto& __r = reinterpret_cast<const whiteout::textures::Texture*>(self)->mipLevel(mip, layer);
    return const_cast<struct whiteout_MipLevel*>(
        reinterpret_cast<const struct whiteout_MipLevel*>(&__r));
}

uint64_t whiteout_textures_Texture_dataSize(const whiteout_Texture* self) {
    return reinterpret_cast<const whiteout::textures::Texture*>(self)->dataSize();
}

whiteout_Bytes whiteout_textures_Texture_data(const whiteout_Texture* self) {
    auto __s = reinterpret_cast<const whiteout::textures::Texture*>(self)->data();
    return whiteout_Bytes{
        reinterpret_cast<const uint8_t*>(__s.data()),
        __s.size(), nullptr };
}

whiteout_Bytes whiteout_textures_Texture_mipData(const whiteout_Texture* self, uint32_t mip, uint32_t layer) {
    auto __s = reinterpret_cast<const whiteout::textures::Texture*>(self)->mipData(mip, layer);
    return whiteout_Bytes{
        reinterpret_cast<const uint8_t*>(__s.data()),
        __s.size(), nullptr };
}

whiteout_Bytes whiteout_textures_Texture_takeData(whiteout_Texture* self) {
    return wrapBytes(reinterpret_cast<whiteout::textures::Texture*>(self)->takeData());
}

void whiteout_textures_Texture_setData(whiteout_Texture* self, const uint8_t* new_data, size_t new_data_size) {
    reinterpret_cast<whiteout::textures::Texture*>(self)->setData(std::vector<whiteout::u8>(new_data, new_data + new_data_size));
}

} // extern "C"

// ── BlpParser ─────────────────────────────────────────────────

extern "C" {

whiteout_BlpParser* whiteout_textures_BlpParser_new(void) {
    return reinterpret_cast<whiteout_BlpParser*>(new whiteout::textures::blp::Parser());
}

void whiteout_textures_BlpParser_delete(whiteout_BlpParser* self) {
    delete reinterpret_cast<whiteout::textures::blp::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_BlpParser_parse(whiteout_BlpParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::blp::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_BlpParser_hasIssues(const whiteout_BlpParser* self) {
    return reinterpret_cast<const whiteout::textures::blp::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_BlpParser_getIssues_count(const whiteout_BlpParser* self) {
    return reinterpret_cast<const whiteout::textures::blp::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── BlpWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_BlpWriter* whiteout_textures_BlpWriter_new(void) {
    return reinterpret_cast<whiteout_BlpWriter*>(new whiteout::textures::blp::Writer());
}

whiteout_BlpWriter* whiteout_textures_BlpWriter_new_pool(void* pool) {
    return reinterpret_cast<whiteout_BlpWriter*>(new whiteout::textures::blp::Writer(reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool)));
}

void whiteout_textures_BlpWriter_delete(whiteout_BlpWriter* self) {
    delete reinterpret_cast<whiteout::textures::blp::Writer*>(self);
}

whiteout_Bytes whiteout_textures_BlpWriter_write(whiteout_BlpWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::blp::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_BlpWriter_hasIssues(const whiteout_BlpWriter* self) {
    return reinterpret_cast<const whiteout::textures::blp::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_BlpWriter_getIssues_count(const whiteout_BlpWriter* self) {
    return reinterpret_cast<const whiteout::textures::blp::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_BlpWriter_getIssues_at(const whiteout_BlpWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::blp::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── PngApngFrameInfo ─────────────────────────────────────────────────

extern "C" {

whiteout_PngApngFrameInfo* whiteout_textures_PngApngFrameInfo_new(void) {
    return reinterpret_cast<whiteout_PngApngFrameInfo*>(new whiteout::textures::png::ApngFrameInfo());
}

void whiteout_textures_PngApngFrameInfo_delete(whiteout_PngApngFrameInfo* self) {
    delete reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self);
}

uint32_t whiteout_textures_PngApngFrameInfo_get_width(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->width;
}

void whiteout_textures_PngApngFrameInfo_set_width(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->width = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_height(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->height;
}

void whiteout_textures_PngApngFrameInfo_set_height(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->height = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_xOffset(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->xOffset;
}

void whiteout_textures_PngApngFrameInfo_set_xOffset(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->xOffset = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_yOffset(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->yOffset;
}

void whiteout_textures_PngApngFrameInfo_set_yOffset(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->yOffset = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_delayMs(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->delayMs;
}

void whiteout_textures_PngApngFrameInfo_set_delayMs(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->delayMs = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_disposeOp(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->disposeOp;
}

void whiteout_textures_PngApngFrameInfo_set_disposeOp(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->disposeOp = value;
}

uint32_t whiteout_textures_PngApngFrameInfo_get_blendOp(const whiteout_PngApngFrameInfo* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrameInfo*>(self)->blendOp;
}

void whiteout_textures_PngApngFrameInfo_set_blendOp(whiteout_PngApngFrameInfo* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrameInfo*>(self)->blendOp = value;
}

} // extern "C"

// ── PngParser ─────────────────────────────────────────────────

extern "C" {

whiteout_PngParser* whiteout_textures_PngParser_new(void) {
    return reinterpret_cast<whiteout_PngParser*>(new whiteout::textures::png::Parser());
}

void whiteout_textures_PngParser_delete(whiteout_PngParser* self) {
    delete reinterpret_cast<whiteout::textures::png::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_PngParser_parse(whiteout_PngParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::png::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_PngParser_hasIssues(const whiteout_PngParser* self) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_PngParser_getIssues_count(const whiteout_PngParser* self) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->getIssues().size();
}

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

int32_t whiteout_textures_PngParser_isAnimated(const whiteout_PngParser* self) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->isAnimated();
}

uint32_t whiteout_textures_PngParser_frameCount(const whiteout_PngParser* self) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->frameCount();
}

uint32_t whiteout_textures_PngParser_loopCount(const whiteout_PngParser* self) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->loopCount();
}

struct whiteout_Texture* whiteout_textures_PngParser_frame(const whiteout_PngParser* self, uint32_t index) {
    auto& __r = reinterpret_cast<const whiteout::textures::png::Parser*>(self)->frame(index);
    return const_cast<struct whiteout_Texture*>(
        reinterpret_cast<const struct whiteout_Texture*>(&__r));
}

uint32_t whiteout_textures_PngParser_frameDelayMs(const whiteout_PngParser* self, uint32_t index) {
    return reinterpret_cast<const whiteout::textures::png::Parser*>(self)->frameDelayMs(index);
}

struct whiteout_PngApngFrameInfo* whiteout_textures_PngParser_frameInfo(const whiteout_PngParser* self, uint32_t index) {
    auto& __r = reinterpret_cast<const whiteout::textures::png::Parser*>(self)->frameInfo(index);
    return const_cast<struct whiteout_PngApngFrameInfo*>(
        reinterpret_cast<const struct whiteout_PngApngFrameInfo*>(&__r));
}

} // extern "C"

// ── PngApngFrame ─────────────────────────────────────────────────

extern "C" {

whiteout_PngApngFrame* whiteout_textures_PngApngFrame_new(void) {
    return reinterpret_cast<whiteout_PngApngFrame*>(new whiteout::textures::png::ApngFrame());
}

void whiteout_textures_PngApngFrame_delete(whiteout_PngApngFrame* self) {
    delete reinterpret_cast<whiteout::textures::png::ApngFrame*>(self);
}

whiteout_Texture* whiteout_textures_PngApngFrame_get_image(whiteout_PngApngFrame* self) {
    return reinterpret_cast<whiteout_Texture*>(&reinterpret_cast<whiteout::textures::png::ApngFrame*>(self)->image);
}

void whiteout_textures_PngApngFrame_set_image(whiteout_PngApngFrame* self, const whiteout_Texture* value) {
    reinterpret_cast<whiteout::textures::png::ApngFrame*>(self)->image = *reinterpret_cast<const whiteout::textures::Texture*>(value);
}

uint32_t whiteout_textures_PngApngFrame_get_delayMs(const whiteout_PngApngFrame* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngFrame*>(self)->delayMs;
}

void whiteout_textures_PngApngFrame_set_delayMs(whiteout_PngApngFrame* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngFrame*>(self)->delayMs = value;
}

} // extern "C"

// ── PngApngSaveOptions ─────────────────────────────────────────────────

extern "C" {

whiteout_PngApngSaveOptions* whiteout_textures_PngApngSaveOptions_new(void) {
    return reinterpret_cast<whiteout_PngApngSaveOptions*>(new whiteout::textures::png::ApngSaveOptions());
}

void whiteout_textures_PngApngSaveOptions_delete(whiteout_PngApngSaveOptions* self) {
    delete reinterpret_cast<whiteout::textures::png::ApngSaveOptions*>(self);
}

uint32_t whiteout_textures_PngApngSaveOptions_get_loopCount(const whiteout_PngApngSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::png::ApngSaveOptions*>(self)->loopCount;
}

void whiteout_textures_PngApngSaveOptions_set_loopCount(whiteout_PngApngSaveOptions* self, uint32_t value) {
    reinterpret_cast<whiteout::textures::png::ApngSaveOptions*>(self)->loopCount = value;
}

} // extern "C"

// ── PngWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_PngWriter* whiteout_textures_PngWriter_new(void) {
    return reinterpret_cast<whiteout_PngWriter*>(new whiteout::textures::png::Writer());
}

void whiteout_textures_PngWriter_delete(whiteout_PngWriter* self) {
    delete reinterpret_cast<whiteout::textures::png::Writer*>(self);
}

whiteout_Bytes whiteout_textures_PngWriter_write(whiteout_PngWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::png::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

whiteout_Bytes whiteout_textures_PngWriter_writeAnimated(whiteout_PngWriter* self, const struct whiteout_PngApngFrame* const* frames, size_t frames_size, struct whiteout_PngApngSaveOptions* opts) {
    return wrapBytes(reinterpret_cast<whiteout::textures::png::Writer*>(self)->writeAnimated(([&]{ std::vector<whiteout::textures::png::ApngFrame> __v; __v.reserve(frames_size); for (size_t __i = 0; __i < frames_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::png::ApngFrame*>(frames[__i])); return __v; })(), *reinterpret_cast<const whiteout::textures::png::ApngSaveOptions*>(opts)));
}

int32_t whiteout_textures_PngWriter_hasIssues(const whiteout_PngWriter* self) {
    return reinterpret_cast<const whiteout::textures::png::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_PngWriter_getIssues_count(const whiteout_PngWriter* self) {
    return reinterpret_cast<const whiteout::textures::png::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_PngWriter_getIssues_at(const whiteout_PngWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::png::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── JpegParser ─────────────────────────────────────────────────

extern "C" {

whiteout_JpegParser* whiteout_textures_JpegParser_new(void) {
    return reinterpret_cast<whiteout_JpegParser*>(new whiteout::textures::jpeg::Parser());
}

whiteout_JpegParser* whiteout_textures_JpegParser_new_pool(void* pool) {
    return reinterpret_cast<whiteout_JpegParser*>(new whiteout::textures::jpeg::Parser(reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool)));
}

void whiteout_textures_JpegParser_delete(whiteout_JpegParser* self) {
    delete reinterpret_cast<whiteout::textures::jpeg::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_JpegParser_parse(whiteout_JpegParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::jpeg::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_JpegParser_hasIssues(const whiteout_JpegParser* self) {
    return reinterpret_cast<const whiteout::textures::jpeg::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_JpegParser_getIssues_count(const whiteout_JpegParser* self) {
    return reinterpret_cast<const whiteout::textures::jpeg::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── JpegWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_JpegWriter* whiteout_textures_JpegWriter_new(void) {
    return reinterpret_cast<whiteout_JpegWriter*>(new whiteout::textures::jpeg::Writer());
}

whiteout_JpegWriter* whiteout_textures_JpegWriter_new_quality_pool_progressive(int32_t quality, void* pool, int32_t progressive) {
    return reinterpret_cast<whiteout_JpegWriter*>(new whiteout::textures::jpeg::Writer(quality, reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool), progressive));
}

void whiteout_textures_JpegWriter_delete(whiteout_JpegWriter* self) {
    delete reinterpret_cast<whiteout::textures::jpeg::Writer*>(self);
}

whiteout_Bytes whiteout_textures_JpegWriter_write(whiteout_JpegWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::jpeg::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_JpegWriter_hasIssues(const whiteout_JpegWriter* self) {
    return reinterpret_cast<const whiteout::textures::jpeg::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_JpegWriter_getIssues_count(const whiteout_JpegWriter* self) {
    return reinterpret_cast<const whiteout::textures::jpeg::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_JpegWriter_getIssues_at(const whiteout_JpegWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::jpeg::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── DdsParser ─────────────────────────────────────────────────

extern "C" {

whiteout_DdsParser* whiteout_textures_DdsParser_new(void) {
    return reinterpret_cast<whiteout_DdsParser*>(new whiteout::textures::dds::Parser());
}

void whiteout_textures_DdsParser_delete(whiteout_DdsParser* self) {
    delete reinterpret_cast<whiteout::textures::dds::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_DdsParser_parse(whiteout_DdsParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::dds::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_DdsParser_hasIssues(const whiteout_DdsParser* self) {
    return reinterpret_cast<const whiteout::textures::dds::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_DdsParser_getIssues_count(const whiteout_DdsParser* self) {
    return reinterpret_cast<const whiteout::textures::dds::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── DdsWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_DdsWriter* whiteout_textures_DdsWriter_new(void) {
    return reinterpret_cast<whiteout_DdsWriter*>(new whiteout::textures::dds::Writer());
}

void whiteout_textures_DdsWriter_delete(whiteout_DdsWriter* self) {
    delete reinterpret_cast<whiteout::textures::dds::Writer*>(self);
}

whiteout_Bytes whiteout_textures_DdsWriter_write(whiteout_DdsWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::dds::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_DdsWriter_hasIssues(const whiteout_DdsWriter* self) {
    return reinterpret_cast<const whiteout::textures::dds::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_DdsWriter_getIssues_count(const whiteout_DdsWriter* self) {
    return reinterpret_cast<const whiteout::textures::dds::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_DdsWriter_getIssues_at(const whiteout_DdsWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::dds::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── BmpParser ─────────────────────────────────────────────────

extern "C" {

whiteout_BmpParser* whiteout_textures_BmpParser_new(void) {
    return reinterpret_cast<whiteout_BmpParser*>(new whiteout::textures::bmp::Parser());
}

void whiteout_textures_BmpParser_delete(whiteout_BmpParser* self) {
    delete reinterpret_cast<whiteout::textures::bmp::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_BmpParser_parse(whiteout_BmpParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::bmp::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_BmpParser_hasIssues(const whiteout_BmpParser* self) {
    return reinterpret_cast<const whiteout::textures::bmp::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_BmpParser_getIssues_count(const whiteout_BmpParser* self) {
    return reinterpret_cast<const whiteout::textures::bmp::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── BmpWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_BmpWriter* whiteout_textures_BmpWriter_new(void) {
    return reinterpret_cast<whiteout_BmpWriter*>(new whiteout::textures::bmp::Writer());
}

void whiteout_textures_BmpWriter_delete(whiteout_BmpWriter* self) {
    delete reinterpret_cast<whiteout::textures::bmp::Writer*>(self);
}

whiteout_Bytes whiteout_textures_BmpWriter_write(whiteout_BmpWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::bmp::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_BmpWriter_hasIssues(const whiteout_BmpWriter* self) {
    return reinterpret_cast<const whiteout::textures::bmp::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_BmpWriter_getIssues_count(const whiteout_BmpWriter* self) {
    return reinterpret_cast<const whiteout::textures::bmp::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_BmpWriter_getIssues_at(const whiteout_BmpWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::bmp::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── TgaParser ─────────────────────────────────────────────────

extern "C" {

whiteout_TgaParser* whiteout_textures_TgaParser_new(void) {
    return reinterpret_cast<whiteout_TgaParser*>(new whiteout::textures::tga::Parser());
}

void whiteout_textures_TgaParser_delete(whiteout_TgaParser* self) {
    delete reinterpret_cast<whiteout::textures::tga::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_TgaParser_parse(whiteout_TgaParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::tga::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_TgaParser_hasIssues(const whiteout_TgaParser* self) {
    return reinterpret_cast<const whiteout::textures::tga::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_TgaParser_getIssues_count(const whiteout_TgaParser* self) {
    return reinterpret_cast<const whiteout::textures::tga::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── TgaWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_TgaWriter* whiteout_textures_TgaWriter_new(void) {
    return reinterpret_cast<whiteout_TgaWriter*>(new whiteout::textures::tga::Writer());
}

void whiteout_textures_TgaWriter_delete(whiteout_TgaWriter* self) {
    delete reinterpret_cast<whiteout::textures::tga::Writer*>(self);
}

whiteout_Bytes whiteout_textures_TgaWriter_write(whiteout_TgaWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::tga::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_TgaWriter_hasIssues(const whiteout_TgaWriter* self) {
    return reinterpret_cast<const whiteout::textures::tga::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_TgaWriter_getIssues_count(const whiteout_TgaWriter* self) {
    return reinterpret_cast<const whiteout::textures::tga::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_TgaWriter_getIssues_at(const whiteout_TgaWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::tga::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── TiffParser ─────────────────────────────────────────────────

extern "C" {

whiteout_TiffParser* whiteout_textures_TiffParser_new(void) {
    return reinterpret_cast<whiteout_TiffParser*>(new whiteout::textures::tiff::Parser());
}

void whiteout_textures_TiffParser_delete(whiteout_TiffParser* self) {
    delete reinterpret_cast<whiteout::textures::tiff::Parser*>(self);
}

struct whiteout_Texture* whiteout_textures_TiffParser_parse(whiteout_TiffParser* self, const uint8_t* buffer, size_t buffer_size) {
    auto __r = reinterpret_cast<whiteout::textures::tiff::Parser*>(self)->parse(std::span<const whiteout::u8>(buffer, buffer_size));
    if (!__r) return nullptr;
    return reinterpret_cast<struct whiteout_Texture*>(
        new whiteout::textures::Texture(std::move(*__r)));
}

int32_t whiteout_textures_TiffParser_hasIssues(const whiteout_TiffParser* self) {
    return reinterpret_cast<const whiteout::textures::tiff::Parser*>(self)->hasIssues();
}

size_t whiteout_textures_TiffParser_getIssues_count(const whiteout_TiffParser* self) {
    return reinterpret_cast<const whiteout::textures::tiff::Parser*>(self)->getIssues().size();
}

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

} // extern "C"

// ── TiffWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_TiffWriter* whiteout_textures_TiffWriter_new(void) {
    return reinterpret_cast<whiteout_TiffWriter*>(new whiteout::textures::tiff::Writer());
}

void whiteout_textures_TiffWriter_delete(whiteout_TiffWriter* self) {
    delete reinterpret_cast<whiteout::textures::tiff::Writer*>(self);
}

whiteout_Bytes whiteout_textures_TiffWriter_write(whiteout_TiffWriter* self, struct whiteout_Texture* texture) {
    return wrapBytes(reinterpret_cast<whiteout::textures::tiff::Writer*>(self)->write(*reinterpret_cast<const whiteout::textures::Texture*>(texture)));
}

int32_t whiteout_textures_TiffWriter_hasIssues(const whiteout_TiffWriter* self) {
    return reinterpret_cast<const whiteout::textures::tiff::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_TiffWriter_getIssues_count(const whiteout_TiffWriter* self) {
    return reinterpret_cast<const whiteout::textures::tiff::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_TiffWriter_getIssues_at(const whiteout_TiffWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::tiff::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"

// ── GifSaveOptions ─────────────────────────────────────────────────

extern "C" {

whiteout_GifSaveOptions* whiteout_textures_GifSaveOptions_new(void) {
    return reinterpret_cast<whiteout_GifSaveOptions*>(new whiteout::textures::gif::SaveOptions());
}

void whiteout_textures_GifSaveOptions_delete(whiteout_GifSaveOptions* self) {
    delete reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self);
}

uint16_t whiteout_textures_GifSaveOptions_get_delayCs(const whiteout_GifSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(self)->delayCs;
}

void whiteout_textures_GifSaveOptions_set_delayCs(whiteout_GifSaveOptions* self, uint16_t value) {
    reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self)->delayCs = value;
}

uint16_t whiteout_textures_GifSaveOptions_get_loopCount(const whiteout_GifSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(self)->loopCount;
}

void whiteout_textures_GifSaveOptions_set_loopCount(whiteout_GifSaveOptions* self, uint16_t value) {
    reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self)->loopCount = value;
}

int32_t whiteout_textures_GifSaveOptions_get_dither(const whiteout_GifSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(self)->dither;
}

void whiteout_textures_GifSaveOptions_set_dither(whiteout_GifSaveOptions* self, int32_t value) {
    reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self)->dither = value;
}

float whiteout_textures_GifSaveOptions_get_ditherStrength(const whiteout_GifSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(self)->ditherStrength;
}

void whiteout_textures_GifSaveOptions_set_ditherStrength(whiteout_GifSaveOptions* self, float value) {
    reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self)->ditherStrength = value;
}

int32_t whiteout_textures_GifSaveOptions_get_transparent(const whiteout_GifSaveOptions* self) {
    return reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(self)->transparent;
}

void whiteout_textures_GifSaveOptions_set_transparent(whiteout_GifSaveOptions* self, int32_t value) {
    reinterpret_cast<whiteout::textures::gif::SaveOptions*>(self)->transparent = value;
}

} // extern "C"

// ── GifWriter ─────────────────────────────────────────────────

extern "C" {

whiteout_GifWriter* whiteout_textures_GifWriter_new(void) {
    return reinterpret_cast<whiteout_GifWriter*>(new whiteout::textures::gif::Writer());
}

whiteout_GifWriter* whiteout_textures_GifWriter_new_pool(void* pool) {
    return reinterpret_cast<whiteout_GifWriter*>(new whiteout::textures::gif::Writer(reinterpret_cast<whiteout::interfaces::WorkerPool*>(pool)));
}

void whiteout_textures_GifWriter_delete(whiteout_GifWriter* self) {
    delete reinterpret_cast<whiteout::textures::gif::Writer*>(self);
}

void whiteout_textures_GifWriter_write(whiteout_GifWriter* self, const char* filePath, const struct whiteout_Texture* const* frames, size_t frames_size) {
    reinterpret_cast<whiteout::textures::gif::Writer*>(self)->write(std::string(filePath ? filePath : ""), ([&]{ std::vector<whiteout::textures::Texture> __v; __v.reserve(frames_size); for (size_t __i = 0; __i < frames_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::Texture*>(frames[__i])); return __v; })());
}

whiteout_Bytes whiteout_textures_GifWriter_write_frames(whiteout_GifWriter* self, const struct whiteout_Texture* const* frames, size_t frames_size) {
    return wrapBytes(reinterpret_cast<whiteout::textures::gif::Writer*>(self)->write(([&]{ std::vector<whiteout::textures::Texture> __v; __v.reserve(frames_size); for (size_t __i = 0; __i < frames_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::Texture*>(frames[__i])); return __v; })()));
}

void whiteout_textures_GifWriter_write_filePath_frames_opts(whiteout_GifWriter* self, const char* filePath, const struct whiteout_Texture* const* frames, size_t frames_size, struct whiteout_GifSaveOptions* opts) {
    reinterpret_cast<whiteout::textures::gif::Writer*>(self)->write(std::string(filePath ? filePath : ""), ([&]{ std::vector<whiteout::textures::Texture> __v; __v.reserve(frames_size); for (size_t __i = 0; __i < frames_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::Texture*>(frames[__i])); return __v; })(), *reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(opts));
}

whiteout_Bytes whiteout_textures_GifWriter_write_frames_opts(whiteout_GifWriter* self, const struct whiteout_Texture* const* frames, size_t frames_size, struct whiteout_GifSaveOptions* opts) {
    return wrapBytes(reinterpret_cast<whiteout::textures::gif::Writer*>(self)->write(([&]{ std::vector<whiteout::textures::Texture> __v; __v.reserve(frames_size); for (size_t __i = 0; __i < frames_size; ++__i) __v.emplace_back(*reinterpret_cast<const whiteout::textures::Texture*>(frames[__i])); return __v; })(), *reinterpret_cast<const whiteout::textures::gif::SaveOptions*>(opts)));
}

int32_t whiteout_textures_GifWriter_hasIssues(const whiteout_GifWriter* self) {
    return reinterpret_cast<const whiteout::textures::gif::Writer*>(self)->hasIssues();
}

size_t whiteout_textures_GifWriter_getIssues_count(const whiteout_GifWriter* self) {
    return reinterpret_cast<const whiteout::textures::gif::Writer*>(self)->getIssues().size();
}

whiteout_CString whiteout_textures_GifWriter_getIssues_at(const whiteout_GifWriter* self, size_t index) {
    const auto& __v = reinterpret_cast<const whiteout::textures::gif::Writer*>(self)->getIssues();
    if (index >= __v.size()) return emptyCString();
    return wrapCString(std::string(__v[index]));
}

} // extern "C"