#include <glad/gl.h>

#include "MMUPaintedTexturePreview.hpp"

#include "3DScene.hpp"
#include "BitmapCache.hpp"
#include "GLShader.hpp"
#include "GUI_App.hpp"

#include "libslic3r/Config.hpp"
#include "libslic3r/Geometry.hpp"
#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/TextureMapping.hpp"
#include "libslic3r/filament_mixer.h"

#include <algorithm>
#include <cmath>
#include <chrono>
#include <functional>
#include <future>
#include <limits>
#include <memory>
#include <numeric>
#include <optional>
#include <unordered_map>
#include <utility>

namespace Slic3r {

namespace {

constexpr float k_preview_offset = 0.001f;
constexpr float k_polygon_offset_factor = -1.f;
constexpr float k_polygon_offset_units = -1.f;
constexpr float k_epsilon = 1e-6f;
constexpr unsigned int k_simulated_texture_preview_max_edge = 1024;
constexpr size_t k_simulated_texture_preview_max_pixels = 1024ull * 1024ull;

struct TexturePreviewMixCandidate
{
    std::array<float, 3> rgb;
    std::vector<float> weights;
};

struct TexturePreviewSimulationSettings
{
    int mapping_mode = int(TextureMappingZone::TextureMappingFilamentBlending);
    int filament_color_mode = TextureMappingZone::DefaultFilamentColorMode;
    bool force_sequential_filaments = false;
    bool limit_texture_resolution = true;
    bool compact_offset_mode = false;
    float contrast_pct = 100.f;
    float tone_gamma = 1.f;
    std::vector<unsigned int> component_ids;
    std::vector<std::array<float, 3>> component_colors;
    std::vector<float> component_strength_factors;
    std::vector<size_t> semantic_component_indices;
    std::vector<TexturePreviewMixCandidate> generic_mix_candidates;
};

struct SurfaceGradientPreviewSettings
{
    std::vector<unsigned int> component_ids;
    std::vector<std::array<float, 3>> component_colors;
    std::vector<float> distances_mm;
    std::vector<float> angles_deg;
    std::vector<float> strength_factors;
    std::vector<float> minimum_offset_factors;
    float max_component_distance_mm = 0.f;
    float max_width_delta_limit_mm = 0.f;
    float sagging_ratio = 0.f;
    int angle_mode = int(TextureMappingZone::OffsetAngleObjectCenter);
    bool rotation_enabled = true;
    float rotations = 1.f;
    float repeats = 1.f;
    bool reverse_repeats = true;
    bool clockwise = true;
    int fade_mode = int(TextureMappingZone::OffsetFadeNone);
    bool limit_texture_resolution = true;
    Vec3f center = Vec3f::Zero();
    float z_min = 0.f;
    float z_max = 0.f;
};

struct TexturePreviewSimulationResult
{
    size_t signature { 0 };
    unsigned int width { 0 };
    unsigned int height { 0 };
    std::vector<unsigned char> rgba;
};

struct TexturePreviewSimulationCacheEntry
{
    std::unique_ptr<GUI::GLTexture> texture;
    size_t uploaded_signature { 0 };
    size_t pending_signature { 0 };
    std::future<TexturePreviewSimulationResult> pending_future;
};

bool model_volume_has_texture_preview_data(const ModelVolume &model_volume)
{
    return !model_volume.imported_texture_rgba.empty() &&
           model_volume.imported_texture_width > 0 &&
           model_volume.imported_texture_height > 0 &&
           model_volume.imported_texture_uv_valid.size() == model_volume.mesh().its.indices.size() &&
           model_volume.imported_texture_uvs_per_face.size() >= model_volume.mesh().its.indices.size() * 6 &&
           model_volume.imported_texture_rgba.size() >=
               size_t(model_volume.imported_texture_width) * size_t(model_volume.imported_texture_height) * 4;
}

bool model_volume_has_vertex_color_preview_data(const ModelVolume &model_volume)
{
    return !model_volume.imported_vertex_colors_rgba.empty() &&
           model_volume.imported_vertex_colors_rgba.size() == model_volume.mesh().its.vertices.size();
}

bool model_volume_has_texture_mapping_color_preview_data(const ModelVolume &model_volume)
{
    return !model_volume.texture_mapping_color_facets.empty();
}

std::array<Vec2f, 3> unwrap_triangle_uvs(const Vec2f &uv0, const Vec2f &uv1, const Vec2f &uv2)
{
    std::array<Vec2f, 3> out{ uv0, uv1, uv2 };

    auto unwrap_axis = [&out](bool use_u_axis) {
        std::array<float, 3> values = {
            use_u_axis ? out[0].x() : out[0].y(),
            use_u_axis ? out[1].x() : out[1].y(),
            use_u_axis ? out[2].x() : out[2].y()
        };
        const float value_min = std::min({ values[0], values[1], values[2] });
        const float value_max = std::max({ values[0], values[1], values[2] });
        if (value_max - value_min <= 0.5f)
            return;

        for (float &value : values)
            if (value < 0.5f)
                value += 1.f;

        if (use_u_axis) {
            out[0].x() = values[0];
            out[1].x() = values[1];
            out[2].x() = values[2];
        } else {
            out[0].y() = values[0];
            out[1].y() = values[1];
            out[2].y() = values[2];
        }
    };

    unwrap_axis(true);
    unwrap_axis(false);
    return out;
}

bool barycentric_weights(const Vec3f &point, const Vec3f &p0, const Vec3f &p1, const Vec3f &p2, Vec3f &weights)
{
    const Vec3f edge_0 = p1 - p0;
    const Vec3f edge_1 = p2 - p0;
    const Vec3f delta = point - p0;
    const float d00 = edge_0.dot(edge_0);
    const float d01 = edge_0.dot(edge_1);
    const float d11 = edge_1.dot(edge_1);
    const float d20 = delta.dot(edge_0);
    const float d21 = delta.dot(edge_1);
    const float denom = d00 * d11 - d01 * d01;
    if (std::abs(denom) <= k_epsilon)
        return false;

    weights.y() = (d11 * d20 - d01 * d21) / denom;
    weights.z() = (d00 * d21 - d01 * d20) / denom;
    weights.x() = 1.f - weights.y() - weights.z();
    return std::isfinite(weights.x()) && std::isfinite(weights.y()) && std::isfinite(weights.z());
}

ColorRGBA unpack_vertex_color(uint32_t packed)
{
    return {
        float((packed >> 24) & 0xFF) / 255.f,
        float((packed >> 16) & 0xFF) / 255.f,
        float((packed >> 8) & 0xFF) / 255.f,
        float(packed & 0xFF) / 255.f
    };
}

ColorRGBA interpolate_color(const std::array<ColorRGBA, 3> &colors, const Vec3f &weights)
{
    Vec3f clamped(std::max(0.f, weights.x()), std::max(0.f, weights.y()), std::max(0.f, weights.z()));
    const float sum = clamped.x() + clamped.y() + clamped.z();
    if (sum > k_epsilon)
        clamped /= sum;
    else
        clamped = Vec3f(1.f / 3.f, 1.f / 3.f, 1.f / 3.f);

    return {
        colors[0].r() * clamped.x() + colors[1].r() * clamped.y() + colors[2].r() * clamped.z(),
        colors[0].g() * clamped.x() + colors[1].g() * clamped.y() + colors[2].g() * clamped.z(),
        colors[0].b() * clamped.x() + colors[1].b() * clamped.y() + colors[2].b() * clamped.z(),
        colors[0].a() * clamped.x() + colors[1].a() * clamped.y() + colors[2].a() * clamped.z()
    };
}

std::array<float, 3> decode_color(const std::string &color)
{
    unsigned char rgba[4] = { 38, 166, 154, 255 };
    GUI::BitmapCache::parse_color4(color, rgba);
    return {
        float(rgba[0]) / 255.f,
        float(rgba[1]) / 255.f,
        float(rgba[2]) / 255.f
    };
}

ColorRGBA blend_component_colors(const std::vector<std::array<float, 3>> &colors, const std::vector<float> &weights)
{
    if (colors.empty() || weights.empty())
        return { 0.15f, 0.65f, 0.6f, 1.f };

    float total = 0.f;
    for (size_t idx = 0; idx < std::min(colors.size(), weights.size()); ++idx)
        total += std::max(0.f, weights[idx]);
    if (total <= k_epsilon)
        return { colors.front()[0], colors.front()[1], colors.front()[2], 1.f };

    float out_r = colors.front()[0];
    float out_g = colors.front()[1];
    float out_b = colors.front()[2];
    float accumulated = std::max(0.f, weights[0]);
    if (accumulated <= k_epsilon) {
        for (size_t idx = 1; idx < std::min(colors.size(), weights.size()); ++idx) {
            if (weights[idx] > k_epsilon) {
                out_r = colors[idx][0];
                out_g = colors[idx][1];
                out_b = colors[idx][2];
                accumulated = weights[idx];
                break;
            }
        }
    }

    for (size_t idx = 1; idx < std::min(colors.size(), weights.size()); ++idx) {
        const float weight = std::max(0.f, weights[idx]);
        if (weight <= k_epsilon)
            continue;
        const float t = weight / std::max(accumulated + weight, k_epsilon);
        filament_mixer_lerp_float(out_r, out_g, out_b, colors[idx][0], colors[idx][1], colors[idx][2], t, &out_r, &out_g, &out_b);
        accumulated += weight;
    }

    return { std::clamp(out_r, 0.f, 1.f), std::clamp(out_g, 0.f, 1.f), std::clamp(out_b, 0.f, 1.f), 1.f };
}

float clamp01(float value)
{
    return std::clamp(value, 0.f, 1.f);
}

unsigned char to_u8(float value)
{
    return static_cast<unsigned char>(clamp01(value) * 255.f + 0.5f);
}

void make_texture_preview_rgba_opaque(std::vector<unsigned char> &rgba)
{
    for (size_t idx = 3; idx < rgba.size(); idx += 4)
        rgba[idx] = 255;
}

void configure_texture_preview_sampler(const GUI::GLTexture &texture)
{
    if (texture.get_id() == 0)
        return;

    glsafe(::glBindTexture(GL_TEXTURE_2D, texture.get_id()));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
    glsafe(::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0));
    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
}

std::array<unsigned int, 2> limited_simulated_texture_preview_size(unsigned int width, unsigned int height)
{
    if (width == 0 || height == 0)
        return { 0, 0 };

    double scale = 1.0;
    const unsigned int max_edge = std::max(width, height);
    if (max_edge > k_simulated_texture_preview_max_edge)
        scale = std::min(scale, double(k_simulated_texture_preview_max_edge) / double(max_edge));

    const double pixel_count = double(width) * double(height);
    if (pixel_count * scale * scale > double(k_simulated_texture_preview_max_pixels))
        scale = std::min(scale, std::sqrt(double(k_simulated_texture_preview_max_pixels) / pixel_count));

    if (scale >= 1.0)
        return { width, height };

    unsigned int limited_width = std::max(1u, unsigned(std::lround(double(width) * scale)));
    unsigned int limited_height = std::max(1u, unsigned(std::lround(double(height) * scale)));
    while (limited_width > k_simulated_texture_preview_max_edge ||
           limited_height > k_simulated_texture_preview_max_edge ||
           size_t(limited_width) * size_t(limited_height) > k_simulated_texture_preview_max_pixels) {
        if (limited_width >= limited_height && limited_width > 1)
            --limited_width;
        else if (limited_height > 1)
            --limited_height;
        else
            break;
    }
    return { limited_width, limited_height };
}

std::array<unsigned char, 3> sample_texture_preview_rgb_bilinear(const std::vector<unsigned char> &rgba,
                                                                 unsigned int width,
                                                                 unsigned int height,
                                                                 unsigned int preview_x,
                                                                 unsigned int preview_y,
                                                                 unsigned int preview_width,
                                                                 unsigned int preview_height)
{
    const double src_x = std::clamp((double(preview_x) + 0.5) * double(width) / double(std::max(1u, preview_width)) - 0.5,
                                    0.0,
                                    double(width - 1));
    const double src_y = std::clamp((double(preview_y) + 0.5) * double(height) / double(std::max(1u, preview_height)) - 0.5,
                                    0.0,
                                    double(height - 1));
    const unsigned int x0 = std::min(width - 1, unsigned(std::floor(src_x)));
    const unsigned int y0 = std::min(height - 1, unsigned(std::floor(src_y)));
    const unsigned int x1 = std::min(width - 1, x0 + 1);
    const unsigned int y1 = std::min(height - 1, y0 + 1);
    const double tx = src_x - double(x0);
    const double ty = src_y - double(y0);

    auto channel_at = [&rgba, width](unsigned int x, unsigned int y, size_t channel) {
        return double(rgba[(size_t(y) * size_t(width) + size_t(x)) * 4 + channel]);
    };
    auto sample_channel = [&](size_t channel) {
        const double top = channel_at(x0, y0, channel) * (1.0 - tx) + channel_at(x1, y0, channel) * tx;
        const double bottom = channel_at(x0, y1, channel) * (1.0 - tx) + channel_at(x1, y1, channel) * tx;
        return static_cast<unsigned char>(std::clamp(int(std::lround(top * (1.0 - ty) + bottom * ty)), 0, 255));
    };

    return { sample_channel(0), sample_channel(1), sample_channel(2) };
}

unsigned int texture_preview_rgb_cache_key(const std::array<unsigned char, 3> &rgb, bool quantize)
{
    if (quantize)
        return unsigned(rgb[0] >> 3) | (unsigned(rgb[1] >> 3) << 5) | (unsigned(rgb[2] >> 3) << 10);
    return unsigned(rgb[0]) | (unsigned(rgb[1]) << 8) | (unsigned(rgb[2]) << 16);
}

unsigned int filament_id_for_state(size_t state_id, unsigned int base_filament_id)
{
    return state_id == 0 ? base_filament_id : unsigned(state_id);
}

const TextureMappingZone *zone_for_filament(unsigned int filament_id, size_t num_physical, const TextureMappingManager *texture_mgr)
{
    return texture_mgr != nullptr && filament_id > num_physical ? texture_mgr->zone_from_id(filament_id) : nullptr;
}

bool is_image_zone(const TextureMappingZone &zone)
{
    return zone.enabled && !zone.deleted && zone.is_image_texture();
}

bool is_gradient_zone(const TextureMappingZone &zone)
{
    return zone.enabled && !zone.deleted && zone.is_2d_gradient();
}

float texture_preview_mix_for_filament(unsigned int filament_id, size_t num_physical, const TextureMappingManager *texture_mgr)
{
    const TextureMappingZone *zone = zone_for_filament(filament_id, num_physical, texture_mgr);
    if (zone == nullptr || (!is_image_zone(*zone) && !is_gradient_zone(*zone)))
        return 0.f;
    return std::clamp(zone->preview_opacity_pct, 0.f, 100.f) / 100.f;
}

bool texture_preview_settings_invalid_for_filament(unsigned int filament_id, size_t num_physical, const TextureMappingManager *texture_mgr)
{
    const TextureMappingZone *zone = zone_for_filament(filament_id, num_physical, texture_mgr);
    if (zone == nullptr)
        return false;
    if (is_image_zone(*zone))
        return TextureMappingManager::component_count_mismatch(*zone, num_physical);
    if (is_gradient_zone(*zone))
        return TextureMappingManager::selected_component_ids(*zone, num_physical).size() < 2;
    return false;
}

std::vector<std::string> physical_filament_colors_for_texture_preview(size_t num_physical)
{
    std::vector<std::string> colors;
    if (GUI::wxGetApp().preset_bundle != nullptr) {
        if (const ConfigOptionStrings *opt = GUI::wxGetApp().preset_bundle->project_config.option<ConfigOptionStrings>("filament_colour"))
            colors = opt->values;
    }
    colors.resize(num_physical, "#26A69A");
    return colors;
}

std::array<float, 3> mix_component_colors_with_filament_mixer(const std::vector<std::array<float, 3>> &component_colors,
                                                              const std::vector<float>                &weights)
{
    if (component_colors.empty() || component_colors.size() != weights.size())
        return { 0.f, 0.f, 0.f };

    bool has_base = false;
    float out_r = 0.f;
    float out_g = 0.f;
    float out_b = 0.f;
    float accumulated = 0.f;
    for (size_t idx = 0; idx < component_colors.size(); ++idx) {
        const float weight = clamp01(weights[idx]);
        if (weight <= k_epsilon)
            continue;

        if (!has_base) {
            out_r = component_colors[idx][0];
            out_g = component_colors[idx][1];
            out_b = component_colors[idx][2];
            accumulated = weight;
            has_base = true;
            continue;
        }

        const float t = weight / std::max(k_epsilon, accumulated + weight);
        float mixed_r = out_r;
        float mixed_g = out_g;
        float mixed_b = out_b;
        filament_mixer_lerp_float(out_r,
                                  out_g,
                                  out_b,
                                  component_colors[idx][0],
                                  component_colors[idx][1],
                                  component_colors[idx][2],
                                  t,
                                  &mixed_r,
                                  &mixed_g,
                                  &mixed_b);
        out_r = clamp01(mixed_r);
        out_g = clamp01(mixed_g);
        out_b = clamp01(mixed_b);
        accumulated += weight;
    }

    if (!has_base)
        return component_colors.front();
    return { out_r, out_g, out_b };
}

float color_distance_sq(const std::array<float, 3> &lhs, const std::array<float, 3> &rhs)
{
    const float dr = lhs[0] - rhs[0];
    const float dg = lhs[1] - rhs[1];
    const float db = lhs[2] - rhs[2];
    return dr * dr + dg * dg + db * db;
}

std::vector<size_t> best_matching_component_indices_for_semantic_colors(const std::vector<std::array<float, 3>> &component_colors,
                                                                        const std::vector<std::array<float, 3>> &semantic_colors)
{
    if (component_colors.empty() || component_colors.size() != semantic_colors.size())
        return {};

    std::vector<size_t> permutation(component_colors.size(), 0);
    std::iota(permutation.begin(), permutation.end(), size_t(0));

    std::vector<size_t> best_permutation = permutation;
    float best_error = std::numeric_limits<float>::max();
    do {
        float error = 0.f;
        for (size_t role_idx = 0; role_idx < semantic_colors.size(); ++role_idx)
            error += color_distance_sq(component_colors[permutation[role_idx]], semantic_colors[role_idx]);

        if (error < best_error) {
            best_error = error;
            best_permutation = permutation;
        }
    } while (std::next_permutation(permutation.begin(), permutation.end()));

    return best_permutation;
}

std::vector<size_t> semantic_component_indices_for_texture_preview(const std::vector<std::array<float, 3>> &component_colors,
                                                                   int filament_color_mode,
                                                                   bool force_sequential_filaments)
{
    if (force_sequential_filaments)
        return {};

    std::vector<std::array<float, 3>> semantic_colors;
    switch (filament_color_mode) {
    case int(TextureMappingZone::FilamentColorRGB):
        semantic_colors = { { { 1.f, 0.f, 0.f } }, { { 0.f, 1.f, 0.f } }, { { 0.f, 0.f, 1.f } } };
        break;
    case int(TextureMappingZone::FilamentColorCMY):
        semantic_colors = { { { 0.f, 1.f, 1.f } }, { { 1.f, 0.f, 1.f } }, { { 1.f, 1.f, 0.f } } };
        break;
    case int(TextureMappingZone::FilamentColorCMYK):
        semantic_colors = { { { 0.f, 1.f, 1.f } }, { { 1.f, 0.f, 1.f } }, { { 1.f, 1.f, 0.f } }, { { 0.f, 0.f, 0.f } } };
        break;
    case int(TextureMappingZone::FilamentColorCMYW):
        semantic_colors = { { { 0.f, 1.f, 1.f } }, { { 1.f, 0.f, 1.f } }, { { 1.f, 1.f, 0.f } }, { { 1.f, 1.f, 1.f } } };
        break;
    case int(TextureMappingZone::FilamentColorRGBK):
        semantic_colors = { { { 1.f, 0.f, 0.f } }, { { 0.f, 1.f, 0.f } }, { { 0.f, 0.f, 1.f } }, { { 0.f, 0.f, 0.f } } };
        break;
    case int(TextureMappingZone::FilamentColorRGBW):
        semantic_colors = { { { 1.f, 0.f, 0.f } }, { { 0.f, 1.f, 0.f } }, { { 0.f, 0.f, 1.f } }, { { 1.f, 1.f, 1.f } } };
        break;
    default:
        return {};
    }

    return best_matching_component_indices_for_semantic_colors(component_colors, semantic_colors);
}

bool texture_preview_uses_generic_solver(const TexturePreviewSimulationSettings &settings)
{
    if (settings.mapping_mode == int(TextureMappingZone::TextureMappingRawValues))
        return false;

    const int clamped_mode = std::clamp(settings.filament_color_mode,
                                        int(TextureMappingZone::FilamentColorAny),
                                        int(TextureMappingZone::FilamentColorBW));
    size_t expected_component_count = 0;
    switch (clamped_mode) {
    case int(TextureMappingZone::FilamentColorRGB):
    case int(TextureMappingZone::FilamentColorCMY):
        expected_component_count = 3;
        break;
    case int(TextureMappingZone::FilamentColorCMYK):
    case int(TextureMappingZone::FilamentColorCMYW):
    case int(TextureMappingZone::FilamentColorRGBK):
    case int(TextureMappingZone::FilamentColorRGBW):
        expected_component_count = 4;
        break;
    case int(TextureMappingZone::FilamentColorBW):
        expected_component_count = 2;
        break;
    default:
        return true;
    }

    return settings.component_colors.size() != expected_component_count;
}

std::vector<TexturePreviewMixCandidate> build_generic_mix_candidates(const std::vector<std::array<float, 3>> &component_colors)
{
    if (component_colors.empty())
        return {};

    const size_t component_count = component_colors.size();
    const int total_units = component_count <= 4 ? 20 : (component_count <= 6 ? 10 : 6);
    std::vector<int> units(component_count, 0);
    std::vector<TexturePreviewMixCandidate> candidates;
    candidates.reserve(4096);

    std::function<void(size_t, int)> recurse = [&](size_t idx, int remaining_units) {
        if (idx + 1 == component_count) {
            units[idx] = remaining_units;
            TexturePreviewMixCandidate candidate;
            candidate.weights.assign(component_count, 0.f);
            for (size_t weight_idx = 0; weight_idx < component_count; ++weight_idx)
                candidate.weights[weight_idx] = float(units[weight_idx]) / float(std::max(1, total_units));
            candidate.rgb = mix_component_colors_with_filament_mixer(component_colors, candidate.weights);
            candidates.emplace_back(std::move(candidate));
            return;
        }

        for (int unit = 0; unit <= remaining_units; ++unit) {
            units[idx] = unit;
            recurse(idx + 1, remaining_units - unit);
        }
    };
    recurse(0, total_units);
    return candidates;
}

std::vector<float> best_component_mix_weights_for_target(const std::vector<TexturePreviewMixCandidate> &candidates,
                                                         const std::array<float, 3>                    &target_rgb)
{
    if (candidates.empty())
        return {};

    const TexturePreviewMixCandidate *best_candidate = nullptr;
    float best_error = std::numeric_limits<float>::max();
    for (const TexturePreviewMixCandidate &candidate : candidates) {
        const float error = color_distance_sq(candidate.rgb, target_rgb);
        if (error < best_error) {
            best_error = error;
            best_candidate = &candidate;
        }
    }

    return best_candidate != nullptr ? best_candidate->weights : std::vector<float>{};
}

float apply_texture_tone_gamma(float channel, float tone_gamma)
{
    const float safe_channel = clamp01(channel);
    const float safe_gamma = (!std::isfinite(tone_gamma) || tone_gamma <= 0.f) ? 1.f : std::clamp(tone_gamma, 0.5f, 3.f);
    if (std::abs(safe_gamma - 1.f) <= 1e-5f)
        return safe_channel;
    return clamp01(std::pow(safe_channel, 1.f / safe_gamma));
}

void apply_texture_contrast_to_mapped_components(std::vector<float> &component_weights,
                                                 float contrast_factor,
                                                 size_t mapped_component_count)
{
    const size_t count = std::min(mapped_component_count, component_weights.size());
    if (count == 0)
        return;

    float mean_weight = 0.f;
    for (size_t idx = 0; idx < count; ++idx)
        mean_weight += clamp01(component_weights[idx]);
    mean_weight /= float(count);

    for (size_t idx = 0; idx < count; ++idx) {
        const float safe_weight = clamp01(component_weights[idx]);
        component_weights[idx] = clamp01(mean_weight + (safe_weight - mean_weight) * contrast_factor);
    }
}

std::vector<float> optimized_primary_component_weights_for_target(const std::array<float, 3>              &target_rgb,
                                                                  size_t                                   component_count,
                                                                  int                                      filament_color_mode,
                                                                  const std::vector<std::array<float, 3>> &component_colors,
                                                                  bool                                     force_sequential_filaments,
                                                                  const std::vector<size_t>               &semantic_component_indices)
{
    const int clamped_mode = std::clamp(filament_color_mode,
                                        int(TextureMappingZone::FilamentColorAny),
                                        int(TextureMappingZone::FilamentColorBW));
    if (clamped_mode == int(TextureMappingZone::FilamentColorAny))
        return {};

    auto print_visibility_strength = [](float value) {
        return clamp01(std::pow(std::max(0.f, value), 0.85f));
    };

    const float r = clamp01(target_rgb[0]);
    const float g = clamp01(target_rgb[1]);
    const float b = clamp01(target_rgb[2]);
    const float whiteness = std::min({ r, g, b });
    const float darkness = 1.f - std::max({ r, g, b });

    auto safe_div = [](float numerator, float denominator) {
        if (denominator <= k_epsilon)
            return 0.f;
        return clamp01(numerator / denominator);
    };
    const auto component_index_for_role = [&semantic_component_indices](size_t role_idx) {
        if (role_idx < semantic_component_indices.size())
            return semantic_component_indices[role_idx];
        return role_idx;
    };

    std::vector<float> weights(component_count, 0.f);
    if (clamped_mode == int(TextureMappingZone::FilamentColorRGB)) {
        if (component_count != 3)
            return {};
        weights[component_index_for_role(0)] = print_visibility_strength(r);
        weights[component_index_for_role(1)] = print_visibility_strength(g);
        weights[component_index_for_role(2)] = print_visibility_strength(b);
        return weights;
    }
    if (clamped_mode == int(TextureMappingZone::FilamentColorCMY)) {
        if (component_count != 3)
            return {};
        weights[component_index_for_role(0)] = print_visibility_strength(1.f - r);
        weights[component_index_for_role(1)] = print_visibility_strength(1.f - g);
        weights[component_index_for_role(2)] = print_visibility_strength(1.f - b);
        return weights;
    }
    if (clamped_mode == int(TextureMappingZone::FilamentColorBW)) {
        if (component_count != 2)
            return {};

        const float gray = clamp01(0.2126f * r + 0.7152f * g + 0.0722f * b);
        const float black_strength = gray >= 0.5f ? (2.f * (1.f - gray)) : 1.f;
        const float white_strength = gray <= 0.5f ? (2.f * gray) : 1.f;

        size_t black_component_idx = 0;
        size_t white_component_idx = 1;
        if (!force_sequential_filaments && component_colors.size() >= 2) {
            const float lum0 = 0.2126f * component_colors[0][0] + 0.7152f * component_colors[0][1] + 0.0722f * component_colors[0][2];
            const float lum1 = 0.2126f * component_colors[1][0] + 0.7152f * component_colors[1][1] + 0.0722f * component_colors[1][2];
            if (lum0 > lum1) {
                black_component_idx = 1;
                white_component_idx = 0;
            }
        }

        weights[black_component_idx] = print_visibility_strength(black_strength);
        weights[white_component_idx] = print_visibility_strength(white_strength);
        return weights;
    }

    if (component_count != 4)
        return {};

    if (clamped_mode == int(TextureMappingZone::FilamentColorCMYK)) {
        const float k = clamp01(darkness);
        const float inv = 1.f - k;
        weights[component_index_for_role(0)] = print_visibility_strength(safe_div(1.f - r - k, inv));
        weights[component_index_for_role(1)] = print_visibility_strength(safe_div(1.f - g - k, inv));
        weights[component_index_for_role(2)] = print_visibility_strength(safe_div(1.f - b - k, inv));
        weights[component_index_for_role(3)] = print_visibility_strength(k);
        return weights;
    }
    if (clamped_mode == int(TextureMappingZone::FilamentColorCMYW)) {
        const float inv = 1.f - whiteness;
        const float r_no_w = safe_div(r - whiteness, inv);
        const float g_no_w = safe_div(g - whiteness, inv);
        const float b_no_w = safe_div(b - whiteness, inv);
        weights[component_index_for_role(0)] = print_visibility_strength((1.f - r_no_w) * inv);
        weights[component_index_for_role(1)] = print_visibility_strength((1.f - g_no_w) * inv);
        weights[component_index_for_role(2)] = print_visibility_strength((1.f - b_no_w) * inv);
        weights[component_index_for_role(3)] = clamp01(std::pow(whiteness, 1.35f));
        return weights;
    }
    if (clamped_mode == int(TextureMappingZone::FilamentColorRGBK)) {
        const float k = clamp01(darkness);
        const float inv = 1.f - k;
        weights[component_index_for_role(0)] = print_visibility_strength(safe_div(r - k, inv) * inv);
        weights[component_index_for_role(1)] = print_visibility_strength(safe_div(g - k, inv) * inv);
        weights[component_index_for_role(2)] = print_visibility_strength(safe_div(b - k, inv) * inv);
        weights[component_index_for_role(3)] = print_visibility_strength(k);
        return weights;
    }
    if (clamped_mode == int(TextureMappingZone::FilamentColorRGBW)) {
        const float inv = 1.f - whiteness;
        weights[component_index_for_role(0)] = print_visibility_strength(safe_div(r - whiteness, inv) * inv);
        weights[component_index_for_role(1)] = print_visibility_strength(safe_div(g - whiteness, inv) * inv);
        weights[component_index_for_role(2)] = print_visibility_strength(safe_div(b - whiteness, inv) * inv);
        weights[component_index_for_role(3)] = clamp01(std::pow(whiteness, 1.35f));
        return weights;
    }

    return {};
}

std::vector<float> component_weights_for_texture_preview(const TexturePreviewSimulationSettings &settings,
                                                         const std::array<float, 4>            &sample_rgba)
{
    const size_t component_count = settings.component_colors.size();
    if (component_count == 0)
        return {};

    std::array<float, 3> target = {
        clamp01(sample_rgba[0]),
        clamp01(sample_rgba[1]),
        clamp01(sample_rgba[2])
    };
    if (std::abs(settings.tone_gamma - 1.f) > 1e-5f) {
        target[0] = apply_texture_tone_gamma(target[0], settings.tone_gamma);
        target[1] = apply_texture_tone_gamma(target[1], settings.tone_gamma);
        target[2] = apply_texture_tone_gamma(target[2], settings.tone_gamma);
    }

    std::vector<float> desired(component_count, 0.f);
    size_t mapped_component_count = component_count;
    if (settings.mapping_mode == int(TextureMappingZone::TextureMappingRawValues)) {
        const float channels[3] = { target[0], target[1], target[2] };
        const size_t channel_count = std::min(component_count, size_t(3));
        for (size_t channel_idx = 0; channel_idx < channel_count; ++channel_idx)
            desired[channel_idx] = clamp01(channels[channel_idx]);
        mapped_component_count = channel_count;
    } else {
        std::vector<float> optimized = optimized_primary_component_weights_for_target(target,
                                                                                      component_count,
                                                                                      settings.filament_color_mode,
                                                                                      settings.component_colors,
                                                                                      settings.force_sequential_filaments,
                                                                                      settings.semantic_component_indices);
        if (optimized.size() == component_count)
            desired = std::move(optimized);
        else {
            std::vector<float> best = best_component_mix_weights_for_target(settings.generic_mix_candidates, target);
            if (best.size() == component_count)
                desired = std::move(best);
        }
    }

    const float contrast_factor = std::clamp(settings.contrast_pct, 25.f, 300.f) / 100.f;
    if (std::abs(contrast_factor - 1.f) > 1e-5f)
        apply_texture_contrast_to_mapped_components(desired, contrast_factor, mapped_component_count);

    if (settings.compact_offset_mode) {
        float max_weight = 0.f;
        for (const float value : desired)
            max_weight = std::max(max_weight, clamp01(value));
        if (max_weight > k_epsilon)
            for (float &value : desired)
                value = clamp01(value / max_weight);
    }

    for (size_t idx = 0; idx < desired.size() && idx < settings.component_strength_factors.size(); ++idx)
        desired[idx] = clamp01(desired[idx] * settings.component_strength_factors[idx]);
    return desired;
}

void prepare_texture_preview_simulation_settings(TexturePreviewSimulationSettings &settings)
{
    settings.semantic_component_indices =
        semantic_component_indices_for_texture_preview(settings.component_colors,
                                                       settings.filament_color_mode,
                                                       settings.force_sequential_filaments);
    if (texture_preview_uses_generic_solver(settings))
        settings.generic_mix_candidates = build_generic_mix_candidates(settings.component_colors);
    else
        settings.generic_mix_candidates.clear();
}

ColorRGBA simulated_texture_preview_color_for_vertex_color(const ColorRGBA *source_color,
                                                           const TexturePreviewSimulationSettings *settings)
{
    if (source_color == nullptr)
        return { 0.f, 0.f, 0.f, 1.f };
    if (settings == nullptr)
        return *source_color;

    const std::array<float, 4> sample_rgba = {
        source_color->r(),
        source_color->g(),
        source_color->b(),
        source_color->a()
    };
    const std::vector<float> component_weights = component_weights_for_texture_preview(*settings, sample_rgba);
    float activity = 0.f;
    for (const float weight : component_weights)
        activity = std::max(activity, clamp01(weight));

    if (activity <= k_epsilon)
        return *source_color;

    const std::array<float, 3> simulated_rgb = mix_component_colors_with_filament_mixer(settings->component_colors, component_weights);
    return { simulated_rgb[0], simulated_rgb[1], simulated_rgb[2], source_color->a() };
}

std::optional<TexturePreviewSimulationSettings> texture_preview_simulation_settings_for_filament(unsigned int filament_id,
                                                                                                 size_t num_physical,
                                                                                                 const TextureMappingManager *texture_mgr,
                                                                                                 const std::vector<std::string> &physical_colors)
{
    const TextureMappingZone *zone = zone_for_filament(filament_id, num_physical, texture_mgr);
    if (zone == nullptr || !is_image_zone(*zone) || !zone->preview_simulate_colors)
        return std::nullopt;

    TexturePreviewSimulationSettings settings;
    settings.mapping_mode = std::clamp(zone->texture_mapping_mode,
                                       int(TextureMappingZone::TextureMappingFilamentBlending),
                                       int(TextureMappingZone::TextureMappingRawValues));
    settings.filament_color_mode = std::clamp(zone->filament_color_mode,
                                              int(TextureMappingZone::FilamentColorAny),
                                              int(TextureMappingZone::FilamentColorBW));
    settings.force_sequential_filaments = zone->force_sequential_filaments;
    settings.limit_texture_resolution = zone->preview_limit_resolution;
    settings.compact_offset_mode = zone->compact_offset_mode;
    settings.contrast_pct = std::clamp(zone->contrast_pct, 25.f, 300.f);
    settings.tone_gamma = (!std::isfinite(zone->tone_gamma) || zone->tone_gamma <= 0.f) ?
        1.f :
        std::clamp(zone->tone_gamma, 0.5f, 3.f);
    settings.component_ids = TextureMappingManager::effective_texture_component_ids(*zone, num_physical, physical_colors);
    if (settings.component_ids.empty())
        return std::nullopt;

    const bool raw_values_mode = settings.mapping_mode == int(TextureMappingZone::TextureMappingRawValues);
    settings.component_colors.reserve(settings.component_ids.size());
    settings.component_strength_factors.reserve(settings.component_ids.size());
    for (const unsigned int component_id : settings.component_ids) {
        if (component_id == 0 || size_t(component_id - 1) >= physical_colors.size()) {
            if (!raw_values_mode)
                return std::nullopt;
            settings.component_colors.emplace_back(std::array<float, 3>{ 0.f, 0.f, 0.f });
        } else {
            settings.component_colors.emplace_back(decode_color(physical_colors[size_t(component_id - 1)]));
        }

        const size_t strength_idx = component_id > 0 ? size_t(component_id - 1) : size_t(0);
        const float strength_pct = strength_idx < zone->filament_strengths_pct.size() ?
            zone->filament_strengths_pct[strength_idx] :
            100.f;
        const float safe_strength_pct = std::isfinite(strength_pct) ? strength_pct : 100.f;
        settings.component_strength_factors.emplace_back(std::clamp(safe_strength_pct / 100.f, 0.f, 1.f));
    }

    return settings.component_colors.empty() ? std::nullopt : std::optional<TexturePreviewSimulationSettings>(std::move(settings));
}

size_t texture_preview_simulation_signature(const ModelVolume &model_volume,
                                            size_t source_signature,
                                            const TexturePreviewSimulationSettings &settings)
{
    size_t signature = source_signature;
    auto mix = [&signature](size_t value) {
        signature ^= value + 0x9e3779b97f4a7c15ull + (signature << 6) + (signature >> 2);
    };

    mix(reinterpret_cast<size_t>(&model_volume));
    mix(std::hash<int>{}(settings.mapping_mode));
    mix(std::hash<int>{}(settings.filament_color_mode));
    mix(std::hash<int>{}(settings.force_sequential_filaments ? 1 : 0));
    mix(std::hash<int>{}(settings.limit_texture_resolution ? 1 : 0));
    mix(std::hash<int>{}(settings.compact_offset_mode ? 1 : 0));
    mix(std::hash<int>{}(int(std::lround(settings.contrast_pct * 100.f))));
    mix(std::hash<int>{}(int(std::lround(settings.tone_gamma * 1000.f))));
    for (const unsigned int id : settings.component_ids)
        mix(std::hash<unsigned int>{}(id));
    for (const auto &color : settings.component_colors) {
        mix(std::hash<int>{}(int(std::lround(color[0] * 255.f))));
        mix(std::hash<int>{}(int(std::lround(color[1] * 255.f))));
        mix(std::hash<int>{}(int(std::lround(color[2] * 255.f))));
    }
    for (const float strength_factor : settings.component_strength_factors)
        mix(std::hash<int>{}(int(std::lround(strength_factor * 1000.f))));
    return signature;
}

TexturePreviewSimulationResult build_simulated_texture_preview_result(size_t signature,
                                                                      unsigned int width,
                                                                      unsigned int height,
                                                                      std::vector<unsigned char> source_rgba,
                                                                      TexturePreviewSimulationSettings settings)
{
    TexturePreviewSimulationResult result;
    result.signature = signature;
    if (width == 0 || height == 0 || source_rgba.size() < size_t(width) * size_t(height) * 4)
        return result;

    const std::array<unsigned int, 2> preview_size = settings.limit_texture_resolution ?
        limited_simulated_texture_preview_size(width, height) :
        std::array<unsigned int, 2>{ width, height };
    result.width = preview_size[0];
    result.height = preview_size[1];
    result.rgba.resize(size_t(result.width) * size_t(result.height) * 4, 0);
    if (result.width == 0 || result.height == 0)
        return result;

    prepare_texture_preview_simulation_settings(settings);
    const bool use_generic_solver = !settings.generic_mix_candidates.empty();

    std::unordered_map<unsigned int, std::array<unsigned char, 4>> simulated_color_cache;
    simulated_color_cache.reserve(std::min(size_t(result.width) * size_t(result.height),
                                           use_generic_solver ? size_t(32768) : size_t(65536)));

    for (unsigned int y = 0; y < result.height; ++y) {
        for (unsigned int x = 0; x < result.width; ++x) {
            const std::array<unsigned char, 3> source_rgb =
                sample_texture_preview_rgb_bilinear(source_rgba, width, height, x, y, result.width, result.height);
            const unsigned int cache_key = texture_preview_rgb_cache_key(source_rgb, use_generic_solver);
            const size_t idx = (size_t(y) * size_t(result.width) + size_t(x)) * 4;

            auto cached_color = simulated_color_cache.find(cache_key);
            if (cached_color != simulated_color_cache.end()) {
                result.rgba[idx + 0] = cached_color->second[0];
                result.rgba[idx + 1] = cached_color->second[1];
                result.rgba[idx + 2] = cached_color->second[2];
                result.rgba[idx + 3] = cached_color->second[3];
                continue;
            }

            const std::array<float, 4> sample_rgba = {
                float(source_rgb[0]) / 255.f,
                float(source_rgb[1]) / 255.f,
                float(source_rgb[2]) / 255.f,
                1.f
            };
            const std::vector<float> component_weights = component_weights_for_texture_preview(settings, sample_rgba);
            float activity = 0.f;
            for (const float weight : component_weights)
                activity = std::max(activity, clamp01(weight));

            const std::array<float, 3> simulated_rgb = activity > k_epsilon ?
                mix_component_colors_with_filament_mixer(settings.component_colors, component_weights) :
                std::array<float, 3>{ sample_rgba[0], sample_rgba[1], sample_rgba[2] };

            const std::array<unsigned char, 4> out_rgba = {
                to_u8(simulated_rgb[0]),
                to_u8(simulated_rgb[1]),
                to_u8(simulated_rgb[2]),
                255
            };
            simulated_color_cache.emplace(cache_key, out_rgba);
            result.rgba[idx + 0] = out_rgba[0];
            result.rgba[idx + 1] = out_rgba[1];
            result.rgba[idx + 2] = out_rgba[2];
            result.rgba[idx + 3] = out_rgba[3];
        }
    }

    return result;
}

std::unordered_map<size_t, std::shared_ptr<TexturePreviewSimulationCacheEntry>> &texture_preview_simulation_cache()
{
    static auto *cache = new std::unordered_map<size_t, std::shared_ptr<TexturePreviewSimulationCacheEntry>>();
    return *cache;
}

std::vector<std::future<TexturePreviewSimulationResult>> &abandoned_texture_preview_futures()
{
    static auto *futures = new std::vector<std::future<TexturePreviewSimulationResult>>();
    return *futures;
}

void discard_ready_texture_preview_future(TexturePreviewSimulationCacheEntry &entry)
{
    if (!entry.pending_future.valid() ||
        entry.pending_future.wait_for(std::chrono::seconds(0)) != std::future_status::ready)
        return;

    try {
        (void) entry.pending_future.get();
    } catch (...) {
    }
    entry.pending_signature = 0;
}

bool prune_abandoned_texture_preview_futures()
{
    bool pending = false;
    auto &futures = abandoned_texture_preview_futures();
    for (auto it = futures.begin(); it != futures.end();) {
        if (!it->valid()) {
            it = futures.erase(it);
            continue;
        }

        if (it->wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
            try {
                (void) it->get();
            } catch (...) {
            }
            it = futures.erase(it);
        } else {
            pending = true;
            ++it;
        }
    }
    return pending;
}

} // namespace

void clear_texture_preview_simulation_cache()
{
    prune_abandoned_texture_preview_futures();

    auto &cache = texture_preview_simulation_cache();
    for (auto it = cache.begin(); it != cache.end();) {
        std::shared_ptr<TexturePreviewSimulationCacheEntry> &entry = it->second;
        if (entry == nullptr) {
            it = cache.erase(it);
            continue;
        }

        if (entry->texture != nullptr) {
            entry->texture->reset();
            entry->texture.reset();
        }
        entry->uploaded_signature = 0;
        entry->pending_signature = 0;

        if (entry->pending_future.valid()) {
            if (entry->pending_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
                discard_ready_texture_preview_future(*entry);
            } else {
                abandoned_texture_preview_futures().emplace_back(std::move(entry->pending_future));
            }
        }
        it = cache.erase(it);
    }
}

namespace {

bool texture_preview_simulation_is_pending_impl()
{
    const bool abandoned_pending = prune_abandoned_texture_preview_futures();
    auto &cache = texture_preview_simulation_cache();
    for (auto it = cache.begin(); it != cache.end();) {
        const std::shared_ptr<TexturePreviewSimulationCacheEntry> &entry = it->second;
        if (entry == nullptr) {
            it = cache.erase(it);
            continue;
        }

        if (!entry->pending_future.valid()) {
            ++it;
            continue;
        }

        if (entry->pending_future.wait_for(std::chrono::seconds(0)) != std::future_status::ready)
            return true;

        if (entry->texture == nullptr && entry->pending_signature == 0) {
            discard_ready_texture_preview_future(*entry);
            it = cache.erase(it);
            continue;
        }

        ++it;
    }
    return abandoned_pending;
}

size_t texture_preview_simulation_cache_key(const ModelVolume &model_volume, unsigned int filament_id)
{
    size_t key = reinterpret_cast<size_t>(&model_volume);
    key ^= std::hash<unsigned int>{}(filament_id) + 0x9e3779b97f4a7c15ull + (key << 6) + (key >> 2);
    return key;
}

const GUI::GLTexture *simulated_texture_preview_texture_for_filament(const ModelVolume &model_volume,
                                                                    unsigned int filament_id,
                                                                    size_t num_physical,
                                                                    const TextureMappingManager *texture_mgr,
                                                                    size_t source_texture_signature,
                                                                    const GUI::GLTexture &fallback_texture)
{
    const std::vector<std::string> physical_colors = physical_filament_colors_for_texture_preview(num_physical);
    std::optional<TexturePreviewSimulationSettings> settings =
        texture_preview_simulation_settings_for_filament(filament_id, num_physical, texture_mgr, physical_colors);
    if (!settings.has_value())
        return &fallback_texture;

    const size_t simulation_signature = texture_preview_simulation_signature(model_volume, source_texture_signature, *settings);
    auto &cache = texture_preview_simulation_cache();
    const size_t cache_key = texture_preview_simulation_cache_key(model_volume, filament_id);
    std::shared_ptr<TexturePreviewSimulationCacheEntry> &entry_ref = cache[cache_key];
    if (entry_ref == nullptr)
        entry_ref = std::make_shared<TexturePreviewSimulationCacheEntry>();
    TexturePreviewSimulationCacheEntry &entry = *entry_ref;

    if (entry.pending_future.valid() && entry.pending_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
        TexturePreviewSimulationResult result = entry.pending_future.get();
        if (result.signature == entry.pending_signature && !result.rgba.empty() && result.width > 0 && result.height > 0) {
            if (entry.texture == nullptr)
                entry.texture = std::make_unique<GUI::GLTexture>();
            else
                entry.texture->reset();

            if (entry.texture->load_from_raw_data(std::move(result.rgba), result.width, result.height)) {
                configure_texture_preview_sampler(*entry.texture);
                entry.uploaded_signature = result.signature;
            } else {
                entry.uploaded_signature = 0;
            }
        }
        entry.pending_signature = 0;
    }

    if (entry.texture != nullptr && entry.uploaded_signature == simulation_signature && entry.texture->get_id() != 0)
        return entry.texture.get();

    if (!entry.pending_future.valid()) {
        entry.pending_signature = simulation_signature;
        const unsigned int width = model_volume.imported_texture_width;
        const unsigned int height = model_volume.imported_texture_height;
        std::vector<unsigned char> source_rgba(model_volume.imported_texture_rgba.begin(), model_volume.imported_texture_rgba.end());
        TexturePreviewSimulationSettings simulation_settings = *settings;
        entry.pending_future = std::async(std::launch::async,
                                          [simulation_signature,
                                           width,
                                           height,
                                           source_rgba = std::move(source_rgba),
                                           simulation_settings = std::move(simulation_settings)]() mutable {
                                              return build_simulated_texture_preview_result(simulation_signature,
                                                                                           width,
                                                                                           height,
                                                                                           std::move(source_rgba),
                                                                                           std::move(simulation_settings));
                                          });
    }

    return &fallback_texture;
}

bool build_texture_preview_model_for_state(const ModelVolume                                      &model_volume,
                                           const std::vector<TriangleSelector::FacetStateTriangle> &state_triangles,
                                           GUI::GLModel                                            &out_model)
{
    if (!model_volume_has_texture_preview_data(model_volume) || state_triangles.empty())
        return false;

    const indexed_triangle_set &its = model_volume.mesh().its;
    GUI::GLModel::Geometry geometry;
    geometry.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GUI::GLModel::Geometry::EVertexLayout::P3N3T2 };
    geometry.reserve_vertices(state_triangles.size() * 3);
    geometry.reserve_indices(state_triangles.size() * 3);

    unsigned int vertex_index = 0;
    for (const TriangleSelector::FacetStateTriangle &triangle : state_triangles) {
        if (triangle.source_triangle < 0)
            continue;

        const size_t source_triangle = size_t(triangle.source_triangle);
        if (source_triangle >= its.indices.size() ||
            source_triangle >= model_volume.imported_texture_uv_valid.size() ||
            model_volume.imported_texture_uv_valid[source_triangle] == 0)
            continue;

        const size_t uv_offset = source_triangle * 6;
        if (uv_offset + 5 >= model_volume.imported_texture_uvs_per_face.size())
            continue;

        const stl_triangle_vertex_indices &source_indices = its.indices[source_triangle];
        if (source_indices[0] < 0 || source_indices[1] < 0 || source_indices[2] < 0)
            continue;
        if (size_t(source_indices[0]) >= its.vertices.size() ||
            size_t(source_indices[1]) >= its.vertices.size() ||
            size_t(source_indices[2]) >= its.vertices.size())
            continue;

        const Vec3f source_p0 = its.vertices[size_t(source_indices[0])].cast<float>();
        const Vec3f source_p1 = its.vertices[size_t(source_indices[1])].cast<float>();
        const Vec3f source_p2 = its.vertices[size_t(source_indices[2])].cast<float>();
        const std::array<Vec2f, 3> source_uvs = unwrap_triangle_uvs(
            Vec2f(model_volume.imported_texture_uvs_per_face[uv_offset + 0], model_volume.imported_texture_uvs_per_face[uv_offset + 1]),
            Vec2f(model_volume.imported_texture_uvs_per_face[uv_offset + 2], model_volume.imported_texture_uvs_per_face[uv_offset + 3]),
            Vec2f(model_volume.imported_texture_uvs_per_face[uv_offset + 4], model_volume.imported_texture_uvs_per_face[uv_offset + 5]));

        Vec3f normal = (triangle.vertices[1] - triangle.vertices[0]).cross(triangle.vertices[2] - triangle.vertices[0]);
        const float normal_len = normal.norm();
        if (normal_len <= k_epsilon)
            continue;
        normal /= normal_len;
        const Vec3f offset = normal * k_preview_offset;

        std::array<Vec2f, 3> leaf_uvs;
        bool valid_leaf = true;
        for (size_t vertex_idx = 0; vertex_idx < triangle.vertices.size(); ++vertex_idx) {
            Vec3f barycentric = Vec3f::Zero();
            if (!barycentric_weights(triangle.vertices[vertex_idx], source_p0, source_p1, source_p2, barycentric)) {
                valid_leaf = false;
                break;
            }
            leaf_uvs[vertex_idx] = source_uvs[0] * barycentric.x() + source_uvs[1] * barycentric.y() + source_uvs[2] * barycentric.z();
        }
        if (!valid_leaf)
            continue;

        for (size_t vertex_idx = 0; vertex_idx < triangle.vertices.size(); ++vertex_idx)
            geometry.add_vertex(triangle.vertices[vertex_idx] + offset, normal, leaf_uvs[vertex_idx]);
        geometry.add_triangle(vertex_index, vertex_index + 1, vertex_index + 2);
        vertex_index += 3;
    }

    if (geometry.is_empty())
        return false;

    out_model.init_from(std::move(geometry));
    return true;
}

bool build_vertex_color_preview_model_for_state(const ModelVolume                                      &model_volume,
                                                const std::vector<TriangleSelector::FacetStateTriangle> &state_triangles,
                                                const TexturePreviewSimulationSettings                   *simulation_settings,
                                                GUI::GLModel                                            &out_model)
{
    if (!model_volume_has_vertex_color_preview_data(model_volume) || state_triangles.empty())
        return false;

    const indexed_triangle_set &its = model_volume.mesh().its;
    GUI::GLModel::Geometry geometry;
    geometry.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GUI::GLModel::Geometry::EVertexLayout::P3N3C4 };
    geometry.reserve_vertices(state_triangles.size() * 3);
    geometry.reserve_indices(state_triangles.size() * 3);

    std::unordered_map<uint32_t, ColorRGBA> simulated_color_cache;
    if (simulation_settings != nullptr)
        simulated_color_cache.reserve(std::min(model_volume.imported_vertex_colors_rgba.size(), size_t(65536)));
    auto source_vertex_color = [simulation_settings, &simulated_color_cache](uint32_t packed) {
        const ColorRGBA source_color = unpack_vertex_color(packed);
        if (simulation_settings == nullptr)
            return source_color;

        auto cached = simulated_color_cache.find(packed);
        if (cached != simulated_color_cache.end())
            return cached->second;

        const ColorRGBA simulated_color = simulated_texture_preview_color_for_vertex_color(&source_color, simulation_settings);
        simulated_color_cache.emplace(packed, simulated_color);
        return simulated_color;
    };

    unsigned int vertex_index = 0;
    for (const TriangleSelector::FacetStateTriangle &triangle : state_triangles) {
        if (triangle.source_triangle < 0)
            continue;

        const size_t source_triangle = size_t(triangle.source_triangle);
        if (source_triangle >= its.indices.size())
            continue;

        const stl_triangle_vertex_indices &source_indices = its.indices[source_triangle];
        if (source_indices[0] < 0 || source_indices[1] < 0 || source_indices[2] < 0)
            continue;
        if (size_t(source_indices[0]) >= its.vertices.size() ||
            size_t(source_indices[1]) >= its.vertices.size() ||
            size_t(source_indices[2]) >= its.vertices.size() ||
            size_t(source_indices[0]) >= model_volume.imported_vertex_colors_rgba.size() ||
            size_t(source_indices[1]) >= model_volume.imported_vertex_colors_rgba.size() ||
            size_t(source_indices[2]) >= model_volume.imported_vertex_colors_rgba.size())
            continue;

        const Vec3f source_p0 = its.vertices[size_t(source_indices[0])].cast<float>();
        const Vec3f source_p1 = its.vertices[size_t(source_indices[1])].cast<float>();
        const Vec3f source_p2 = its.vertices[size_t(source_indices[2])].cast<float>();
        const std::array<ColorRGBA, 3> source_colors = {
            source_vertex_color(model_volume.imported_vertex_colors_rgba[size_t(source_indices[0])]),
            source_vertex_color(model_volume.imported_vertex_colors_rgba[size_t(source_indices[1])]),
            source_vertex_color(model_volume.imported_vertex_colors_rgba[size_t(source_indices[2])])
        };

        Vec3f normal = (triangle.vertices[1] - triangle.vertices[0]).cross(triangle.vertices[2] - triangle.vertices[0]);
        const float normal_len = normal.norm();
        if (normal_len <= k_epsilon)
            continue;
        normal /= normal_len;
        const Vec3f offset = normal * k_preview_offset;

        std::array<ColorRGBA, 3> leaf_colors;
        bool valid_leaf = true;
        for (size_t vertex_idx = 0; vertex_idx < triangle.vertices.size(); ++vertex_idx) {
            Vec3f barycentric = Vec3f::Zero();
            if (!barycentric_weights(triangle.vertices[vertex_idx], source_p0, source_p1, source_p2, barycentric)) {
                valid_leaf = false;
                break;
            }
            leaf_colors[vertex_idx] = interpolate_color(source_colors, barycentric);
        }
        if (!valid_leaf)
            continue;

        for (size_t vertex_idx = 0; vertex_idx < triangle.vertices.size(); ++vertex_idx)
            geometry.add_vertex(triangle.vertices[vertex_idx] + offset, normal, leaf_colors[vertex_idx]);
        geometry.add_triangle(vertex_index, vertex_index + 1, vertex_index + 2);
        vertex_index += 3;
    }

    if (geometry.is_empty())
        return false;

    out_model.init_from(std::move(geometry));
    return true;
}

std::optional<ColorRGBA> sample_texture_mapping_color_preview(
    const std::vector<ColorFacetTriangle>     &color_facets,
    const std::unordered_map<int, std::vector<size_t>> &facets_by_source_triangle,
    int                                        source_triangle,
    const Vec3f                               &point)
{
    auto found = facets_by_source_triangle.find(source_triangle);
    if (found == facets_by_source_triangle.end() || found->second.empty())
        return std::nullopt;

    const float tolerance = -1e-4f;
    for (const size_t facet_idx : found->second) {
        if (facet_idx >= color_facets.size())
            continue;

        const ColorFacetTriangle &facet = color_facets[facet_idx];
        Vec3f weights = Vec3f::Zero();
        if (!barycentric_weights(point, facet.vertices[0], facet.vertices[1], facet.vertices[2], weights))
            continue;
        if (weights.x() >= tolerance && weights.y() >= tolerance && weights.z() >= tolerance)
            return unpack_vertex_color(facet.rgba);
    }

    return unpack_vertex_color(color_facets[found->second.front()].rgba);
}

bool build_texture_mapping_color_preview_model_for_state(
    const ModelVolume                                      &model_volume,
    const std::vector<TriangleSelector::FacetStateTriangle> &state_triangles,
    const TexturePreviewSimulationSettings                  *simulation_settings,
    GUI::GLModel                                            &out_model,
    const ColorFacetsAnnotation                             *texture_mapping_color_facets_override = nullptr)
{
    const ColorFacetsAnnotation *color_source = texture_mapping_color_facets_override;
    if (color_source == nullptr || color_source->empty())
        color_source = &model_volume.texture_mapping_color_facets;
    if (color_source == nullptr || color_source->empty() || state_triangles.empty())
        return false;

    std::vector<ColorFacetTriangle> color_facets;
    color_source->get_facet_triangles(model_volume, color_facets);
    if (color_facets.empty())
        return false;

    std::unordered_map<int, std::vector<size_t>> facets_by_source_triangle;
    facets_by_source_triangle.reserve(color_facets.size());
    for (size_t idx = 0; idx < color_facets.size(); ++idx)
        facets_by_source_triangle[color_facets[idx].source_triangle].emplace_back(idx);

    GUI::GLModel::Geometry geometry;
    geometry.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GUI::GLModel::Geometry::EVertexLayout::P3N3C4 };
    geometry.reserve_vertices(color_facets.size() * 3);
    geometry.reserve_indices(color_facets.size() * 3);

    std::unordered_map<uint32_t, ColorRGBA> simulated_color_cache;
    if (simulation_settings != nullptr)
        simulated_color_cache.reserve(std::min(color_facets.size(), size_t(65536)));
    auto preview_color = [simulation_settings, &simulated_color_cache](const ColorRGBA &source_color) {
        if (simulation_settings == nullptr)
            return source_color;

        const uint32_t key = (uint32_t(std::clamp(source_color.r(), 0.f, 1.f) * 255.f + 0.5f) << 24) |
                             (uint32_t(std::clamp(source_color.g(), 0.f, 1.f) * 255.f + 0.5f) << 16) |
                             (uint32_t(std::clamp(source_color.b(), 0.f, 1.f) * 255.f + 0.5f) << 8) |
                             uint32_t(std::clamp(source_color.a(), 0.f, 1.f) * 255.f + 0.5f);
        auto cached = simulated_color_cache.find(key);
        if (cached != simulated_color_cache.end())
            return cached->second;

        const ColorRGBA simulated_color = simulated_texture_preview_color_for_vertex_color(&source_color, simulation_settings);
        simulated_color_cache.emplace(key, simulated_color);
        return simulated_color;
    };

    unsigned int vertex_index = 0;
    for (const TriangleSelector::FacetStateTriangle &triangle : state_triangles) {
        if (triangle.source_triangle < 0)
            continue;

        const Vec3f edge_0 = triangle.vertices[1] - triangle.vertices[0];
        const Vec3f edge_1 = triangle.vertices[2] - triangle.vertices[0];
        Vec3f normal = edge_0.cross(edge_1);
        const float normal_len = normal.norm();
        if (normal_len <= k_epsilon)
            continue;
        normal /= normal_len;
        const Vec3f offset = normal * k_preview_offset;

        bool emitted_color_facets = false;
        auto color_facets_for_triangle = facets_by_source_triangle.find(triangle.source_triangle);
        if (color_facets_for_triangle != facets_by_source_triangle.end()) {
            const float tolerance = -1e-4f;
            for (const size_t facet_idx : color_facets_for_triangle->second) {
                if (facet_idx >= color_facets.size())
                    continue;

                const ColorFacetTriangle &facet = color_facets[facet_idx];
                const Vec3f centroid = (facet.vertices[0] + facet.vertices[1] + facet.vertices[2]) / 3.f;
                Vec3f weights = Vec3f::Zero();
                if (!barycentric_weights(centroid, triangle.vertices[0], triangle.vertices[1], triangle.vertices[2], weights))
                    continue;
                if (weights.x() < tolerance || weights.y() < tolerance || weights.z() < tolerance)
                    continue;

                const ColorRGBA color = preview_color(unpack_vertex_color(facet.rgba));
                geometry.add_vertex(facet.vertices[0] + offset, normal, color);
                geometry.add_vertex(facet.vertices[1] + offset, normal, color);
                geometry.add_vertex(facet.vertices[2] + offset, normal, color);
                geometry.add_triangle(vertex_index, vertex_index + 1, vertex_index + 2);
                vertex_index += 3;
                emitted_color_facets = true;
            }
        }

        if (emitted_color_facets)
            continue;

        std::array<ColorRGBA, 3> leaf_colors;
        bool valid_leaf = true;
        for (size_t vertex_idx = 0; vertex_idx < triangle.vertices.size(); ++vertex_idx) {
            std::optional<ColorRGBA> sampled =
                sample_texture_mapping_color_preview(color_facets,
                                                     facets_by_source_triangle,
                                                     triangle.source_triangle,
                                                     triangle.vertices[vertex_idx]);
            if (!sampled) {
                valid_leaf = false;
                break;
            }
            leaf_colors[vertex_idx] = preview_color(*sampled);
        }

        if (!valid_leaf)
            continue;

        geometry.add_vertex(triangle.vertices[0] + offset, normal, leaf_colors[0]);
        geometry.add_vertex(triangle.vertices[1] + offset, normal, leaf_colors[1]);
        geometry.add_vertex(triangle.vertices[2] + offset, normal, leaf_colors[2]);
        geometry.add_triangle(vertex_index, vertex_index + 1, vertex_index + 2);
        vertex_index += 3;
    }

    if (geometry.is_empty())
        return false;

    out_model.init_from(std::move(geometry));
    return true;
}

float normalize_angle(float angle)
{
    if (!std::isfinite(angle))
        return 0.f;
    float out = std::fmod(angle, 360.f);
    if (out < 0.f)
        out += 360.f;
    return out;
}

float angular_distance_deg(float a, float b)
{
    const float d = std::abs(normalize_angle(a) - normalize_angle(b));
    return std::min(d, 360.f - d);
}

float angular_distance_cw(float from_deg, float to_deg)
{
    float d = normalize_angle(to_deg) - normalize_angle(from_deg);
    if (d < 0.f)
        d += 360.f;
    return d;
}

float component_angular_influence(unsigned int component_id,
                                  float theta_deg,
                                  const std::vector<unsigned int> &component_ids,
                                  const std::vector<float> &component_angles_deg)
{
    if (component_ids.empty() || component_ids.size() != component_angles_deg.size())
        return 0.f;

    const auto active_it = std::find(component_ids.begin(), component_ids.end(), component_id);
    if (active_it == component_ids.end())
        return 0.f;
    if (component_ids.size() == 1)
        return 1.f;

    struct SortedComponentAngle {
        float angle_deg { 0.f };
        size_t component_idx { 0 };
    };

    std::vector<SortedComponentAngle> sorted_angles;
    sorted_angles.reserve(component_ids.size());
    for (size_t i = 0; i < component_ids.size(); ++i)
        sorted_angles.push_back({ normalize_angle(component_angles_deg[i]), i });

    std::sort(sorted_angles.begin(), sorted_angles.end(), [](const SortedComponentAngle &lhs, const SortedComponentAngle &rhs) {
        return lhs.angle_deg < rhs.angle_deg;
    });

    const size_t active_component_idx = size_t(active_it - component_ids.begin());
    const auto sorted_active_it = std::find_if(sorted_angles.begin(), sorted_angles.end(), [active_component_idx](const SortedComponentAngle &entry) {
        return entry.component_idx == active_component_idx;
    });
    if (sorted_active_it == sorted_angles.end())
        return 0.f;

    const size_t sorted_pos = size_t(sorted_active_it - sorted_angles.begin());
    const size_t count = sorted_angles.size();
    const float prev_angle = sorted_angles[(sorted_pos + count - 1) % count].angle_deg;
    const float self_angle = sorted_angles[sorted_pos].angle_deg;
    const float next_angle = sorted_angles[(sorted_pos + 1) % count].angle_deg;
    const float prev_to_self_deg = angular_distance_cw(prev_angle, self_angle);
    const float self_to_next_deg = angular_distance_cw(self_angle, next_angle);

    if (prev_to_self_deg <= 1e-3f || self_to_next_deg <= 1e-3f) {
        float total_weight = 0.f;
        float active_weight = 0.f;
        for (size_t i = 0; i < component_ids.size(); ++i) {
            const float dist = angular_distance_deg(theta_deg, component_angles_deg[i]);
            const float weight = std::max(0.f, 1.f - dist / 180.f);
            total_weight += weight;
            if (component_ids[i] == component_id)
                active_weight += weight;
        }

        if (total_weight <= k_epsilon)
            return 0.f;
        return std::clamp(active_weight / total_weight, 0.f, 1.f);
    }

    const float theta_norm = normalize_angle(theta_deg);
    const float prev_to_theta_deg = angular_distance_cw(prev_angle, theta_norm);
    if (prev_to_theta_deg <= prev_to_self_deg + 1e-4f)
        return std::clamp(prev_to_theta_deg / prev_to_self_deg, 0.f, 1.f);

    const float self_to_theta_deg = angular_distance_cw(self_angle, theta_norm);
    if (self_to_theta_deg <= self_to_next_deg + 1e-4f)
        return std::clamp(1.f - self_to_theta_deg / self_to_next_deg, 0.f, 1.f);

    return 0.f;
}

std::vector<unsigned int> decode_surface_gradient_component_ids(const TextureMappingZone &zone, size_t num_physical)
{
    std::vector<unsigned int> ids;
    bool seen[10] = { false };
    for (const char c : zone.component_ids) {
        if (c < '1' || c > '9')
            continue;
        const unsigned int id = unsigned(c - '0');
        if (id == 0 || id > num_physical || seen[id])
            continue;
        seen[id] = true;
        ids.emplace_back(id);
    }

    auto append_component = [&ids, &seen, num_physical](unsigned int id) {
        if (id == 0 || id > num_physical || id > 9 || seen[id])
            return;
        seen[id] = true;
        ids.emplace_back(id);
    };

    if (ids.size() < 2) {
        ids.clear();
        for (bool &flag : seen)
            flag = false;
        append_component(zone.component_a);
        append_component(zone.component_b);
    }

    return ids;
}

float repeated_rotation_progress(float progress01, float repeats, bool reverse_repeats)
{
    const float p = clamp01(progress01);
    const float r = std::max(1.f, repeats);
    if (r <= 1.f + k_epsilon)
        return p;

    float repeated_pos = p * r;
    int segment_idx = int(std::floor(repeated_pos));
    float local = repeated_pos - float(segment_idx);

    if (p >= 1.f - k_epsilon) {
        segment_idx = std::max(0, int(std::ceil(r)) - 1);
        local = 1.f;
    }

    if (reverse_repeats && (segment_idx % 2 == 1))
        local = 1.f - local;
    return clamp01(local);
}

float offset_fade_factor(int fade_mode, float progress01)
{
    const float p = clamp01(progress01);
    switch (fade_mode) {
    case int(TextureMappingZone::OffsetFadeInUp):
        return p;
    case int(TextureMappingZone::OffsetFadeOutUp):
        return 1.f - p;
    case int(TextureMappingZone::OffsetFadeInOut):
        return 1.f - std::abs(2.f * p - 1.f);
    case int(TextureMappingZone::OffsetFadeOutIn):
        return std::abs(2.f * p - 1.f);
    case int(TextureMappingZone::OffsetFadeOutInReversed):
        return 2.f * p - 1.f;
    default:
        return 1.f;
    }
}

float variable_width_delta(float inset_strength,
                           float max_width_delta_limit_mm,
                           float minimum_offset_factor,
                           float strength_factor)
{
    if (!std::isfinite(max_width_delta_limit_mm) || max_width_delta_limit_mm <= 0.f)
        return 0.f;

    const float desired_width_factor = 1.f - std::clamp(inset_strength, 0.f, 1.f);
    const float min_width_factor = std::clamp(minimum_offset_factor, 0.f, 1.f);
    const float adjusted_width_factor =
        min_width_factor + desired_width_factor * std::clamp(strength_factor, 0.f, 1.f) * (1.f - min_width_factor);

    return std::clamp(max_width_delta_limit_mm * (1.f - adjusted_width_factor), 0.f, max_width_delta_limit_mm);
}

ColorRGBA surface_gradient_preview_color_from_weights(const SurfaceGradientPreviewSettings &settings,
                                                      const std::vector<float>             &weights)
{
    const std::array<float, 3> rgb = mix_component_colors_with_filament_mixer(settings.component_colors, weights);
    return { rgb[0], rgb[1], rgb[2], 1.f };
}

ColorRGBA surface_gradient_preview_color_at(const SurfaceGradientPreviewSettings &settings,
                                            const Vec3f                          &position,
                                            const Vec3f                          &normal)
{
    if (settings.component_ids.empty() || settings.component_ids.size() != settings.component_colors.size())
        return { 0.15f, 0.65f, 0.6f, 1.f };

    const float z_span = settings.z_max - settings.z_min;
    const float z_progress = z_span > k_epsilon ?
        std::clamp((position.z() - settings.z_min) / z_span, 0.f, 1.f) :
        0.f;

    float rotation_deg = 0.f;
    if (settings.rotation_enabled) {
        const float repeated = repeated_rotation_progress(z_progress, std::max(1.f, settings.repeats), settings.reverse_repeats);
        const float direction = settings.clockwise ? -1.f : 1.f;
        rotation_deg = direction * 360.f * settings.rotations * repeated;
    }

    std::vector<float> rotated_angles = settings.angles_deg;
    for (float &angle : rotated_angles)
        angle = normalize_angle(angle + rotation_deg);

    Vec2f direction = Vec2f::Zero();
    if (settings.angle_mode == int(TextureMappingZone::OffsetAngleSurfaceNormal))
        direction = Vec2f(normal.x(), normal.y());

    if (direction.squaredNorm() <= k_epsilon) {
        const Vec3f radial = position - settings.center;
        direction = Vec2f(radial.x(), radial.y());
    }
    if (direction.squaredNorm() <= k_epsilon)
        direction = Vec2f(1.f, 0.f);

    const float theta_deg = normalize_angle(float(Geometry::rad2deg(std::atan2(direction.y(), direction.x()))));

    const size_t component_count = settings.component_ids.size();
    std::vector<float> influences(component_count, 0.f);
    for (size_t i = 0; i < component_count; ++i)
        influences[i] = component_angular_influence(settings.component_ids[i], theta_deg, settings.component_ids, rotated_angles);

    const float fade_factor = std::abs(offset_fade_factor(settings.fade_mode, z_progress));
    std::vector<float> edge_reaches(component_count, 0.f);
    for (size_t i = 0; i < component_count; ++i) {
        float raw_inset_mm = 0.f;
        for (size_t j = 0; j < component_count; ++j) {
            if (i == j)
                continue;
            const float distance_mm = j < settings.distances_mm.size() ? settings.distances_mm[j] : 0.f;
            raw_inset_mm += distance_mm * influences[j];
        }

        const float inset_strength = std::clamp(raw_inset_mm / std::max(settings.max_component_distance_mm, k_epsilon), 0.f, 1.f);
        const float strength_factor = i < settings.strength_factors.size() ? settings.strength_factors[i] : 1.f;
        const float minimum_offset_factor = i < settings.minimum_offset_factors.size() ? settings.minimum_offset_factors[i] : 0.f;
        const float width_delta_mm = variable_width_delta(inset_strength * fade_factor,
                                                          settings.max_width_delta_limit_mm,
                                                          minimum_offset_factor,
                                                          strength_factor);
        edge_reaches[i] = std::clamp(settings.max_width_delta_limit_mm - width_delta_mm, 0.f, settings.max_width_delta_limit_mm);
    }

    const auto minmax_reach = std::minmax_element(edge_reaches.begin(), edge_reaches.end());
    std::vector<float> weights(component_count, 0.f);
    if (minmax_reach.first != edge_reaches.end() && (*minmax_reach.second - *minmax_reach.first) > k_epsilon) {
        const float base_reach = *minmax_reach.first;
        const float reach_span = *minmax_reach.second - base_reach;
        for (size_t i = 0; i < component_count; ++i)
            weights[i] = std::clamp((edge_reaches[i] - base_reach) / reach_span, 0.f, 1.f);
    } else {
        std::fill(weights.begin(), weights.end(), 1.f);
    }

    return surface_gradient_preview_color_from_weights(settings, weights);
}

float surface_gradient_preview_config_float(const char *key, float fallback)
{
    if (GUI::wxGetApp().preset_bundle == nullptr)
        return fallback;

    const DynamicPrintConfig &config = GUI::wxGetApp().preset_bundle->project_config;
    if (const ConfigOptionFloat *opt = config.option<ConfigOptionFloat>(key))
        return std::isfinite(opt->value) ? float(opt->value) : fallback;
    return fallback;
}

std::optional<SurfaceGradientPreviewSettings> surface_gradient_preview_settings_for_zone(const ModelVolume &model_volume,
                                                                                        const Transform3d &world_matrix,
                                                                                        const TextureMappingZone &zone,
                                                                                        size_t num_physical)
{
    if (!is_gradient_zone(zone))
        return std::nullopt;

    const std::vector<std::string> colors = physical_filament_colors_for_texture_preview(num_physical);
    SurfaceGradientPreviewSettings settings;
    settings.component_ids = decode_surface_gradient_component_ids(zone, num_physical);
    if (settings.component_ids.size() < 2)
        return std::nullopt;

    settings.component_colors.reserve(settings.component_ids.size());
    settings.strength_factors.reserve(settings.component_ids.size());
    settings.minimum_offset_factors.reserve(settings.component_ids.size());
    for (const unsigned int component_id : settings.component_ids) {
        if (component_id == 0 || size_t(component_id - 1) >= colors.size())
            return std::nullopt;
        settings.component_colors.emplace_back(decode_color(colors[size_t(component_id - 1)]));

        const size_t idx = size_t(component_id - 1);
        const float strength_pct = idx < zone.filament_strengths_pct.size() ? zone.filament_strengths_pct[idx] : 100.f;
        const float minimum_offset_pct = idx < zone.filament_minimum_offsets_pct.size() ? zone.filament_minimum_offsets_pct[idx] : 0.f;
        settings.strength_factors.emplace_back(std::clamp((std::isfinite(strength_pct) ? strength_pct : 100.f) / 100.f, 0.f, 1.f));
        settings.minimum_offset_factors.emplace_back(std::clamp((std::isfinite(minimum_offset_pct) ? minimum_offset_pct : 0.f) / 100.f, 0.f, 1.f));
    }

    const float max_distance_mm = TextureMappingManager::max_component_surface_offset_mm();
    settings.max_component_distance_mm = max_distance_mm;
    settings.distances_mm = TextureMappingManager::effective_offset_distances(zone, settings.component_ids.size());
    bool has_nonzero_distance = false;
    for (float &distance_mm : settings.distances_mm) {
        distance_mm = std::clamp(distance_mm, 0.f, max_distance_mm);
        has_nonzero_distance = has_nonzero_distance || distance_mm > k_epsilon;
    }
    if (!has_nonzero_distance)
        return std::nullopt;

    settings.angles_deg = TextureMappingManager::effective_offset_angles(zone, settings.component_ids.size());
    settings.angle_mode = std::clamp(zone.offset_angle_mode,
                                     int(TextureMappingZone::OffsetAngleConfigured),
                                     int(TextureMappingZone::OffsetAngleObjectCenter));
    settings.rotation_enabled = zone.offset_rotation_enabled;
    settings.rotations = std::isfinite(zone.offset_rotations) ? zone.offset_rotations : 1.f;
    settings.repeats = std::isfinite(zone.offset_repeats) ? std::max(1.f, zone.offset_repeats) : 1.f;
    settings.reverse_repeats = zone.offset_reverse_repeats;
    settings.clockwise = zone.offset_clockwise;
    settings.fade_mode = std::clamp(zone.offset_fade_mode,
                                    int(TextureMappingZone::OffsetFadeNone),
                                    int(TextureMappingZone::OffsetFadeOutInReversed));
    settings.limit_texture_resolution = zone.preview_limit_resolution;
    settings.sagging_ratio = std::isfinite(zone.sagging_ratio) ? std::clamp(zone.sagging_ratio, 0.f, 6.f) : 0.f;

    const float base_outer_width_mm = std::max(0.05f, surface_gradient_preview_config_float("texture_mapping_outer_wall_gradient_max_line_width", 0.95f));
    const float min_outer_width_mm = std::clamp(surface_gradient_preview_config_float("texture_mapping_outer_wall_gradient_min_line_width", 0.32f),
                                                0.05f,
                                                base_outer_width_mm);
    const float global_strength_factor =
        std::clamp(surface_gradient_preview_config_float("texture_mapping_outer_wall_gradient_global_strength", 100.f) / 100.f, 0.f, 1.f);
    settings.max_width_delta_limit_mm = std::min((base_outer_width_mm - min_outer_width_mm) * global_strength_factor, 2.f * max_distance_mm);
    if (settings.sagging_ratio > k_epsilon) {
        constexpr float preview_layer_height_mm = 0.2f;
        settings.max_width_delta_limit_mm = std::min(settings.max_width_delta_limit_mm, preview_layer_height_mm * settings.sagging_ratio);
    }
    if (!std::isfinite(settings.max_width_delta_limit_mm) || settings.max_width_delta_limit_mm <= k_epsilon)
        return std::nullopt;

    const indexed_triangle_set &its = model_volume.mesh().its;
    if (its.vertices.empty())
        return std::nullopt;

    Vec3f min_pt(std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
    Vec3f max_pt(std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest());
    for (const stl_vertex &vertex : its.vertices) {
        const Vec3f p = (world_matrix * vertex.cast<double>()).cast<float>();
        min_pt = min_pt.cwiseMin(p);
        max_pt = max_pt.cwiseMax(p);
    }

    settings.center = 0.5f * (min_pt + max_pt);
    settings.z_min = min_pt.z();
    settings.z_max = max_pt.z();
    return settings;
}

bool build_surface_gradient_vertex_color_preview_model_for_state(const std::vector<TriangleSelector::FacetStateTriangle> &state_triangles,
                                                                 const SurfaceGradientPreviewSettings &settings,
                                                                 const Transform3d &world_matrix,
                                                                 GUI::GLModel &out_model)
{
    if (state_triangles.empty())
        return false;

    GUI::GLModel::Geometry geometry;
    geometry.format = { GUI::GLModel::Geometry::EPrimitiveType::Triangles, GUI::GLModel::Geometry::EVertexLayout::P3N3C4 };
    geometry.reserve_vertices(state_triangles.size() * 3);
    geometry.reserve_indices(state_triangles.size() * 3);

    unsigned int vertex_index = 0;
    for (const TriangleSelector::FacetStateTriangle &triangle : state_triangles) {
        Vec3f normal = (triangle.vertices[1] - triangle.vertices[0]).cross(triangle.vertices[2] - triangle.vertices[0]);
        const float normal_len = normal.norm();
        if (normal_len <= k_epsilon)
            continue;
        normal /= normal_len;
        const Vec3f offset = normal * k_preview_offset;

        const Vec3f world_vertices[3] = {
            (world_matrix * triangle.vertices[0].cast<double>()).cast<float>(),
            (world_matrix * triangle.vertices[1].cast<double>()).cast<float>(),
            (world_matrix * triangle.vertices[2].cast<double>()).cast<float>()
        };
        Vec3f world_normal = (world_vertices[1] - world_vertices[0]).cross(world_vertices[2] - world_vertices[0]);
        const float world_normal_len = world_normal.norm();
        if (world_normal_len <= k_epsilon)
            world_normal = normal;
        else
            world_normal /= world_normal_len;

        const ColorRGBA c0 = surface_gradient_preview_color_at(settings, world_vertices[0], world_normal);
        const ColorRGBA c1 = surface_gradient_preview_color_at(settings, world_vertices[1], world_normal);
        const ColorRGBA c2 = surface_gradient_preview_color_at(settings, world_vertices[2], world_normal);

        geometry.add_vertex(triangle.vertices[0] + offset, normal, c0);
        geometry.add_vertex(triangle.vertices[1] + offset, normal, c1);
        geometry.add_vertex(triangle.vertices[2] + offset, normal, c2);
        geometry.add_triangle(vertex_index, vertex_index + 1, vertex_index + 2);
        vertex_index += 3;
    }

    if (geometry.is_empty())
        return false;

    out_model.init_from(std::move(geometry));
    return true;
}

struct TexturePreviewRenderState
{
    GLboolean blend_enabled { GL_FALSE };
    GLboolean cull_face_enabled { GL_FALSE };
    GLboolean polygon_offset_fill_enabled { GL_FALSE };
    GLboolean depth_mask { GL_TRUE };
    GLint     cull_face_mode { GL_BACK };
    GLfloat   polygon_offset_factor { 0.f };
    GLfloat   polygon_offset_units { 0.f };
    GLint     depth_func { GL_LESS };
};

TexturePreviewRenderState begin_render_state(bool opaque)
{
    TexturePreviewRenderState state;
    state.blend_enabled = glIsEnabled(GL_BLEND);
    state.cull_face_enabled = glIsEnabled(GL_CULL_FACE);
    state.polygon_offset_fill_enabled = glIsEnabled(GL_POLYGON_OFFSET_FILL);
    glsafe(::glGetBooleanv(GL_DEPTH_WRITEMASK, &state.depth_mask));
    glsafe(::glGetIntegerv(GL_CULL_FACE_MODE, &state.cull_face_mode));
    glsafe(::glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &state.polygon_offset_factor));
    glsafe(::glGetFloatv(GL_POLYGON_OFFSET_UNITS, &state.polygon_offset_units));
    glsafe(::glGetIntegerv(GL_DEPTH_FUNC, &state.depth_func));

    if (opaque) {
        glsafe(::glDisable(GL_BLEND));
    } else {
        glsafe(::glEnable(GL_BLEND));
        glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
    }
    glsafe(::glDisable(GL_CULL_FACE));
    glsafe(::glDepthMask(opaque ? GL_TRUE : GL_FALSE));
    glsafe(::glDepthFunc(GL_LEQUAL));
    glsafe(::glEnable(GL_POLYGON_OFFSET_FILL));
    glsafe(::glPolygonOffset(k_polygon_offset_factor, k_polygon_offset_units));
    return state;
}

void restore_render_state(const TexturePreviewRenderState &state)
{
    glsafe(::glPolygonOffset(state.polygon_offset_factor, state.polygon_offset_units));
    if (!state.polygon_offset_fill_enabled)
        glsafe(::glDisable(GL_POLYGON_OFFSET_FILL));
    glsafe(::glDepthFunc(state.depth_func));
    glsafe(::glDepthMask(state.depth_mask));
    glsafe(::glCullFace(state.cull_face_mode));
    if (state.cull_face_enabled)
        glsafe(::glEnable(GL_CULL_FACE));
    else
        glsafe(::glDisable(GL_CULL_FACE));
    if (state.blend_enabled)
        glsafe(::glEnable(GL_BLEND));
    else
        glsafe(::glDisable(GL_BLEND));
}

void set_common_uniforms(GLShaderProgram &shader,
                         const Transform3d &model_matrix,
                         const Transform3d &view_matrix,
                         const Transform3d &projection_matrix,
                         const std::array<float, 2> &z_range,
                         const std::array<float, 4> &clipping_plane,
                         int print_volume_type,
                         const std::array<float, 4> &print_volume_xy,
                         const std::array<float, 2> &print_volume_z)
{
    const Transform3d view_model_matrix = view_matrix * model_matrix;
    const Matrix3d view_normal_matrix = view_matrix.matrix().block(0, 0, 3, 3) *
                                        model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose();

    shader.set_uniform("view_model_matrix", view_model_matrix);
    shader.set_uniform("projection_matrix", projection_matrix);
    shader.set_uniform("view_normal_matrix", view_normal_matrix);
    shader.set_uniform("volume_world_matrix", model_matrix);
    shader.set_uniform("z_range", z_range);
    shader.set_uniform("clipping_plane", clipping_plane);
    shader.set_uniform("print_volume.type", print_volume_type);
    shader.set_uniform("print_volume.xy_data", print_volume_xy);
    shader.set_uniform("print_volume.z_data", print_volume_z);
}

} // namespace

bool texture_preview_simulation_is_pending()
{
    return texture_preview_simulation_is_pending_impl();
}

bool build_mmu_texture_preview_models(
    const ModelVolume                                                    &model_volume,
    const std::vector<std::vector<TriangleSelector::FacetStateTriangle>> &triangles_per_type,
    const std::vector<ColorRGBA>                                         &state_colors,
    unsigned int                                                          base_filament_id,
    size_t                                                                num_physical,
    const TextureMappingManager                                          *texture_mgr,
    std::vector<GUI::GLModel>                                            &out_models,
    std::vector<ColorRGBA>                                               &out_colors,
    std::vector<unsigned int>                                            &out_filament_ids)
{
    out_models.clear();
    out_colors.clear();
    out_filament_ids.clear();
    if (!model_volume_has_texture_preview_data(model_volume))
        return false;

    bool built_any = false;
    for (size_t state_id = 0; state_id < triangles_per_type.size(); ++state_id) {
        const unsigned int filament_id = filament_id_for_state(state_id, base_filament_id);
        const TextureMappingZone *zone = zone_for_filament(filament_id, num_physical, texture_mgr);
        if (zone == nullptr || !is_image_zone(*zone))
            continue;

        GUI::GLModel model;
        if (!build_texture_preview_model_for_state(model_volume, triangles_per_type[state_id], model))
            continue;

        out_models.emplace_back(std::move(model));
        out_colors.emplace_back(state_id < state_colors.size() ? state_colors[state_id] :
                                (state_colors.empty() ? ColorRGBA(0.15f, 0.65f, 0.6f, 1.f) : state_colors.back()));
        out_filament_ids.emplace_back(filament_id);
        built_any = true;
    }
    return built_any;
}

bool build_mmu_vertex_color_preview_models(
    const ModelVolume                                                    &model_volume,
    const std::vector<std::vector<TriangleSelector::FacetStateTriangle>> &triangles_per_type,
    const std::vector<ColorRGBA>                                         &state_colors,
    unsigned int                                                          base_filament_id,
    size_t                                                                num_physical,
    const TextureMappingManager                                          *texture_mgr,
    const Transform3d                                                    &world_matrix,
    std::vector<GUI::GLModel>                                            &out_models,
    std::vector<ColorRGBA>                                               &out_colors,
    std::vector<unsigned int>                                            &out_filament_ids,
    const ColorFacetsAnnotation                                          *texture_mapping_color_facets_override)
{
    out_models.clear();
    out_colors.clear();
    out_filament_ids.clear();

    const bool has_texture_mapping_color_override =
        texture_mapping_color_facets_override != nullptr && !texture_mapping_color_facets_override->empty();
    if (triangles_per_type.empty() || (texture_mgr == nullptr && !has_texture_mapping_color_override))
        return false;

    const std::vector<std::string> physical_colors = physical_filament_colors_for_texture_preview(num_physical);
    bool built_any = false;
    for (size_t state_id = 0; state_id < triangles_per_type.size(); ++state_id) {
        const unsigned int filament_id = filament_id_for_state(state_id, base_filament_id);
        const TextureMappingZone *zone = zone_for_filament(filament_id, num_physical, texture_mgr);
        if (zone == nullptr) {
            if (!has_texture_mapping_color_override || state_id != 0)
                continue;

            GUI::GLModel model;
            if (!build_texture_mapping_color_preview_model_for_state(model_volume,
                                                                     triangles_per_type[state_id],
                                                                     nullptr,
                                                                     model,
                                                                     texture_mapping_color_facets_override) ||
                !model.is_initialized())
                continue;

            out_models.emplace_back(std::move(model));
            out_colors.emplace_back(state_id < state_colors.size() ? state_colors[state_id] :
                                    (state_colors.empty() ? ColorRGBA(0.15f, 0.65f, 0.6f, 1.f) : state_colors.back()));
            out_filament_ids.emplace_back(0u);
            built_any = true;
            continue;
        }
        if (!is_image_zone(*zone) && !is_gradient_zone(*zone))
            continue;

        GUI::GLModel model;
        if (is_gradient_zone(*zone)) {
            std::optional<SurfaceGradientPreviewSettings> settings = surface_gradient_preview_settings_for_zone(model_volume, world_matrix, *zone, num_physical);
            if (!settings)
                continue;
            if (!build_surface_gradient_vertex_color_preview_model_for_state(triangles_per_type[state_id], *settings, world_matrix, model))
                continue;
        } else {
            std::optional<TexturePreviewSimulationSettings> simulation_settings =
                texture_preview_simulation_settings_for_filament(filament_id, num_physical, texture_mgr, physical_colors);
            if (simulation_settings)
                prepare_texture_preview_simulation_settings(*simulation_settings);
            const bool has_texture_mapping_color_preview =
                has_texture_mapping_color_override || model_volume_has_texture_mapping_color_preview_data(model_volume);
            if (has_texture_mapping_color_preview) {
                const ColorFacetsAnnotation *preview_override =
                    has_texture_mapping_color_override ? texture_mapping_color_facets_override : nullptr;
                if (!build_texture_mapping_color_preview_model_for_state(model_volume,
                                                                         triangles_per_type[state_id],
                                                                         simulation_settings ? &*simulation_settings : nullptr,
                                                                         model,
                                                                         preview_override))
                    continue;
            } else {
                if (!build_vertex_color_preview_model_for_state(model_volume,
                                                                triangles_per_type[state_id],
                                                                simulation_settings ? &*simulation_settings : nullptr,
                                                                model))
                    continue;
            }
        }

        out_models.emplace_back(std::move(model));
        out_colors.emplace_back(state_id < state_colors.size() ? state_colors[state_id] :
                                (state_colors.empty() ? ColorRGBA(0.15f, 0.65f, 0.6f, 1.f) : state_colors.back()));
        out_filament_ids.emplace_back(filament_id);
        built_any = true;
    }
    return built_any;
}

bool build_mmu_vertex_color_preview_models(
    const ModelVolume                                                    &model_volume,
    const std::vector<std::vector<TriangleSelector::FacetStateTriangle>> &triangles_per_type,
    const std::vector<ColorRGBA>                                         &state_colors,
    unsigned int                                                          base_filament_id,
    size_t                                                                num_physical,
    const TextureMappingManager                                          *texture_mgr,
    std::vector<GUI::GLModel>                                            &out_models,
    std::vector<ColorRGBA>                                               &out_colors,
    std::vector<unsigned int>                                            &out_filament_ids,
    const ColorFacetsAnnotation                                          *texture_mapping_color_facets_override)
{
    return build_mmu_vertex_color_preview_models(model_volume,
                                                 triangles_per_type,
                                                 state_colors,
                                                 base_filament_id,
                                                 num_physical,
                                                 texture_mgr,
                                                 Transform3d::Identity(),
                                                 out_models,
                                                 out_colors,
                                                 out_filament_ids,
                                                 texture_mapping_color_facets_override);
}

size_t model_volume_texture_preview_signature(const ModelVolume &model_volume)
{
    size_t signature = 1469598103934665603ull;
    auto mix = [&signature](size_t value) {
        signature ^= value + 0x9e3779b97f4a7c15ull + (signature << 6) + (signature >> 2);
    };
    mix(size_t(model_volume.imported_texture_width));
    mix(size_t(model_volume.imported_texture_height));
    mix(model_volume.imported_texture_rgba.size());
    mix(reinterpret_cast<size_t>(model_volume.imported_texture_rgba.data()));
    mix(model_volume.imported_texture_uvs_per_face.size());
    mix(reinterpret_cast<size_t>(model_volume.imported_texture_uvs_per_face.data()));
    mix(model_volume.imported_texture_uv_valid.size());
    mix(reinterpret_cast<size_t>(model_volume.imported_texture_uv_valid.data()));
    return signature;
}

size_t model_volume_texture_mapping_color_preview_signature(const ModelVolume &model_volume)
{
    size_t signature = 1469598103934665603ull;
    auto mix = [&signature](size_t value) {
        signature ^= value + 0x9e3779b97f4a7c15ull + (signature << 6) + (signature >> 2);
    };

    const TriangleColorSplittingData &data = model_volume.texture_mapping_color_facets.get_data();
    mix(data.triangles_to_split.size());
    mix(data.bitstream.size());
    mix(data.colors_rgba.size());
    for (const ColorTriangleBitStreamMapping &mapping : data.triangles_to_split) {
        mix(size_t(mapping.triangle_idx));
        mix(size_t(mapping.bitstream_start_idx));
        mix(size_t(mapping.color_start_idx));
    }
    for (const bool bit : data.bitstream)
        mix(bit ? 1u : 0u);
    for (const uint32_t color : data.colors_rgba)
        mix(size_t(color));
    for (const char ch : data.metadata_json)
        mix(size_t(static_cast<unsigned char>(ch)));
    return signature;
}

bool ensure_model_volume_texture_preview(const ModelVolume &model_volume,
                                         GUI::GLTexture    &texture,
                                         size_t            &texture_signature)
{
    if (!model_volume_has_texture_preview_data(model_volume))
        return false;

    const size_t preview_signature = model_volume_texture_preview_signature(model_volume);
    if (texture.get_id() != 0 && texture_signature == preview_signature)
        return true;

    texture.reset();
    std::vector<unsigned char> texture_data(model_volume.imported_texture_rgba.begin(), model_volume.imported_texture_rgba.end());
    make_texture_preview_rgba_opaque(texture_data);
    if (!texture.load_from_raw_data(std::move(texture_data), model_volume.imported_texture_width, model_volume.imported_texture_height)) {
        texture_signature = 0;
        return false;
    }

    configure_texture_preview_sampler(texture);
    texture_signature = preview_signature;
    return true;
}

size_t texture_preview_settings_signature(size_t num_physical, const TextureMappingManager *texture_mgr)
{
    size_t signature = 1469598103934665603ull;
    auto signature_mix = [&signature](size_t value) {
        signature ^= value + 0x9e3779b97f4a7c15ull + (signature << 6) + (signature >> 2);
    };
    auto signature_mix_float = [&signature_mix](float value, float scale = 1000.f) {
        const float safe_value = std::isfinite(value) ? value : 0.f;
        signature_mix(std::hash<int>{}(int(std::lround(safe_value * scale))));
    };

    signature_mix(std::hash<size_t>{}(num_physical));
    if (GUI::wxGetApp().preset_bundle != nullptr) {
        if (const ConfigOptionStrings *opt = GUI::wxGetApp().preset_bundle->project_config.option<ConfigOptionStrings>("filament_colour"))
            for (const std::string &color : opt->values)
                signature_mix(std::hash<std::string>{}(color));
    }
    if (texture_mgr == nullptr)
        return signature;

    for (const TextureMappingZone &zone : texture_mgr->zones()) {
        signature_mix(std::hash<uint64_t>{}(zone.stable_id));
        signature_mix(std::hash<unsigned int>{}(zone.zone_id));
        signature_mix(std::hash<int>{}(zone.enabled ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.deleted ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.surface_pattern));
        signature_mix(std::hash<unsigned int>{}(zone.component_a));
        signature_mix(std::hash<unsigned int>{}(zone.component_b));
        signature_mix(std::hash<std::string>{}(zone.component_ids));
        signature_mix(std::hash<std::string>{}(zone.component_weights));
        signature_mix(std::hash<std::string>{}(zone.offset_distances));
        signature_mix(std::hash<std::string>{}(zone.offset_angles));
        signature_mix(std::hash<int>{}(zone.offset_mode));
        signature_mix(std::hash<int>{}(zone.offset_rotation_enabled ? 1 : 0));
        signature_mix_float(zone.offset_rotations);
        signature_mix_float(zone.offset_repeats);
        signature_mix(std::hash<int>{}(zone.offset_reverse_repeats ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.offset_clockwise ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.offset_fade_mode));
        signature_mix(std::hash<int>{}(zone.offset_angle_mode));
        signature_mix(std::hash<int>{}(zone.texture_mapping_mode));
        signature_mix(std::hash<int>{}(zone.filament_color_mode));
        signature_mix(std::hash<int>{}(zone.force_sequential_filaments ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.nonlinear_offset_adjustment ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.compact_offset_mode ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.preview_simulate_colors ? 1 : 0));
        signature_mix(std::hash<int>{}(zone.preview_limit_resolution ? 1 : 0));
        signature_mix_float(zone.sagging_ratio);
        signature_mix_float(zone.preview_opacity_pct, 100.f);
        signature_mix_float(zone.contrast_pct, 100.f);
        signature_mix_float(zone.tone_gamma);
        for (const float strength_pct : zone.filament_strengths_pct)
            signature_mix_float(strength_pct, 100.f);
        for (const float minimum_offset_pct : zone.filament_minimum_offsets_pct)
            signature_mix_float(minimum_offset_pct, 100.f);
    }
    return signature;
}

void render_model_texture_preview_models(
    std::vector<GUI::GLModel>       &models,
    const std::vector<ColorRGBA>    &colors,
    const std::vector<unsigned int> &filament_ids,
    size_t                           num_physical,
    const TextureMappingManager     *texture_mgr,
    const ModelVolume               &model_volume,
    const GUI::GLTexture            &texture,
    const Transform3d               &model_matrix,
    const Transform3d               &view_matrix,
    const Transform3d               &projection_matrix,
    const std::array<float, 2>      &z_range,
    const std::array<float, 4>      &clipping_plane,
    int                              print_volume_type,
    const std::array<float, 4>      &print_volume_xy,
    const std::array<float, 2>      &print_volume_z,
    bool                             opaque)
{
    if (models.empty() || colors.size() != models.size() || filament_ids.size() != models.size() || texture.get_id() == 0)
        return;

    GLShaderProgram *shader = GUI::wxGetApp().get_shader("painted_texture_preview");
    if (shader == nullptr)
        return;

    const TexturePreviewRenderState render_state = begin_render_state(opaque);
    shader->start_using();
    set_common_uniforms(*shader, model_matrix, view_matrix, projection_matrix, z_range, clipping_plane, print_volume_type, print_volume_xy, print_volume_z);
    glsafe(::glActiveTexture(GL_TEXTURE0));
    shader->set_uniform("uniform_texture", 0);

    const size_t texture_signature = model_volume_texture_preview_signature(model_volume);
    GLuint bound_texture_id = 0;
    for (size_t idx = 0; idx < models.size(); ++idx) {
        const bool raw_vertex_color_preview = filament_ids[idx] == 0;
        const float mix = raw_vertex_color_preview ?
            1.f :
            texture_preview_mix_for_filament(filament_ids[idx], num_physical, texture_mgr);
        const bool invalid = raw_vertex_color_preview ?
            false :
            texture_preview_settings_invalid_for_filament(filament_ids[idx], num_physical, texture_mgr);
        if (mix <= 0.f && !invalid)
            continue;

        const GUI::GLTexture *preview_texture = simulated_texture_preview_texture_for_filament(model_volume,
                                                                                               filament_ids[idx],
                                                                                               num_physical,
                                                                                               texture_mgr,
                                                                                               texture_signature,
                                                                                               texture);
        if (preview_texture == nullptr || preview_texture->get_id() == 0)
            continue;

        if (preview_texture->get_id() != bound_texture_id) {
            glsafe(::glBindTexture(GL_TEXTURE_2D, preview_texture->get_id()));
            bound_texture_id = preview_texture->get_id();
        }

        shader->set_uniform("texture_preview_mix", mix);
        shader->set_uniform("invalid_texture_mapping", invalid);
        models[idx].set_color(colors[idx]);
        models[idx].render();
    }

    glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
    shader->stop_using();
    restore_render_state(render_state);
}

void render_model_vertex_color_preview_models(
    std::vector<GUI::GLModel>       &models,
    const std::vector<ColorRGBA>    &colors,
    const std::vector<unsigned int> &filament_ids,
    size_t                           num_physical,
    const TextureMappingManager     *texture_mgr,
    const Transform3d               &model_matrix,
    const Transform3d               &view_matrix,
    const Transform3d               &projection_matrix,
    const std::array<float, 2>      &z_range,
    const std::array<float, 4>      &clipping_plane,
    int                              print_volume_type,
    const std::array<float, 4>      &print_volume_xy,
    const std::array<float, 2>      &print_volume_z,
    bool                             opaque)
{
    if (models.empty() || colors.size() != models.size() || filament_ids.size() != models.size())
        return;

    GLShaderProgram *shader = GUI::wxGetApp().get_shader("painted_vertex_color_preview");
    if (shader == nullptr)
        return;

    const TexturePreviewRenderState render_state = begin_render_state(opaque);
    shader->start_using();
    set_common_uniforms(*shader, model_matrix, view_matrix, projection_matrix, z_range, clipping_plane, print_volume_type, print_volume_xy, print_volume_z);

    for (size_t idx = 0; idx < models.size(); ++idx) {
        const float mix = texture_preview_mix_for_filament(filament_ids[idx], num_physical, texture_mgr);
        const bool invalid = texture_preview_settings_invalid_for_filament(filament_ids[idx], num_physical, texture_mgr);
        if (mix <= 0.f && !invalid)
            continue;
        shader->set_uniform("texture_preview_mix", mix);
        shader->set_uniform("invalid_texture_mapping", invalid);
        models[idx].set_color(colors[idx]);
        models[idx].render();
    }

    shader->stop_using();
    restore_render_state(render_state);
}

} // namespace Slic3r