#include "Gallery_Plots.hpp"
#include "Renderable_Adapter.hpp"
#include <render_3D/Render_3D.hpp>
#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <numbers>
#include <random>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <vector>

namespace aethera::web {
namespace {
using namespace render_3d;
using Scene_3D = Impl<Render_Scene_3D>;

using Json = nlohmann::json;

Json number_field(std::string key, std::string label, std::string description,
                  double value, double minimum, double maximum, double step) {
    return {{"key", std::move(key)}, {"label", std::move(label)}, {"description", std::move(description)},
            {"editor", "number"}, {"editable", true}, {"value", value},
            {"minimum", minimum}, {"maximum", maximum}, {"step", step}};
}

Json integer_field(std::string key, std::string label, std::string description,
                   std::size_t value, std::size_t minimum, std::size_t maximum) {
    auto field = number_field(std::move(key), std::move(label), std::move(description),
                              static_cast<double>(value), static_cast<double>(minimum),
                              static_cast<double>(maximum), 1.0);
    field["editor"] = "integer";
    return field;
}

template <typename Definition>
Json generator_schema() {
    Json fields = Json::array();
    if constexpr (std::same_as<Definition, Volume_Visual>) {
        fields.push_back(integer_field("width", "体数据宽度", "体素网格 X 方向尺寸；总量为宽×高×深。", 64, 1, 256));
        fields.push_back(integer_field("height", "体数据高度", "体素网格 Y 方向尺寸；总量为宽×高×深。", 64, 1, 256));
        fields.push_back(integer_field("depth", "体数据深度", "体素网格 Z 方向尺寸；总量为宽×高×深。", 64, 1, 256));
        fields.push_back(number_field("value_min", "体素值下界", "每个体素随机标量值的下界。", 0.0, -1'000'000.0, 1'000'000.0, 0.01));
        fields.push_back(number_field("value_max", "体素值上界", "每个体素随机标量值的上界，必须大于下界。", 1.0, -1'000'000.0, 1'000'000.0, 0.01));
        fields.push_back(integer_field("seed", "随机种子", "固定种子可复现体素压力数据，便于跨策略对比。", 42, 1, 4'294'967'295ULL));
        return {{"label", "生成体素标量场"}, {"description", "按三维网格尺寸生成连续体数据，不使用随机位置。"}, {"fields", std::move(fields)}};
    }
    fields.push_back(integer_field("count", "图元数量", "本次替换到 Visual 的图元数量；用于逐级提升 CPU Prepare、GPU 上传与绘制压力。", 10'000, 1, 5'000'000));
    fields.push_back(integer_field("seed", "随机种子", "固定种子可复现相同空间分布，确保多图与传输模式的性能结果可比较。", 42, 1, 4'294'967'295ULL));
    fields.push_back(number_field("x_min", "Scene X 下界", "随机位置在 Scene X 轴上的下界。", -1.0, -1'000'000.0, 1'000'000.0, 0.01));
    fields.push_back(number_field("x_max", "Scene X 上界", "随机位置在 Scene X 轴上的上界，必须大于下界。", 1.0, -1'000'000.0, 1'000'000.0, 0.01));
    fields.push_back(number_field("y_min", "Scene Y 下界", "随机位置在 Scene Y 轴上的下界。", -1.0, -1'000'000.0, 1'000'000.0, 0.01));
    fields.push_back(number_field("y_max", "Scene Y 上界", "随机位置在 Scene Y 轴上的上界，必须大于下界。", 1.0, -1'000'000.0, 1'000'000.0, 0.01));
    fields.push_back(number_field("z_min", "Scene Z 下界", "随机位置在 Scene Z 轴上的下界。", -1.0, -1'000'000.0, 1'000'000.0, 0.01));
    fields.push_back(number_field("z_max", "Scene Z 上界", "随机位置在 Scene Z 轴上的上界，必须大于下界。", 1.0, -1'000'000.0, 1'000'000.0, 0.01));
    std::string label{"生成三维图元"};
    std::string description{"按各轴独立范围随机生成 Scene 坐标。"};
    if constexpr (std::same_as<Definition, Point_Visual>) {
        label = "生成三维点";
        fields.push_back(number_field("diameter_min", "点直径下界", "随机点直径下界，单位为屏幕像素。", 2.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("diameter_max", "点直径上界", "随机点直径上界，单位为屏幕像素。", 12.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Splat_Visual>) {
        label = "生成三维高斯 Splat";
        fields.push_back(number_field("sigma_min", "标准差下界", "高斯主轴标准差下界，使用 Scene 坐标。", 0.01, 0.0001, 1000.0, 0.001));
        fields.push_back(number_field("sigma_max", "标准差上界", "高斯主轴标准差上界，使用 Scene 坐标。", 0.08, 0.0001, 1000.0, 0.001));
        fields.push_back(number_field("angle_min", "旋转角下界", "Splat 主轴旋转角下界，单位为弧度。", -3.14159, -1000.0, 1000.0, 0.01));
        fields.push_back(number_field("angle_max", "旋转角上界", "Splat 主轴旋转角上界，单位为弧度。", 3.14159, -1000.0, 1000.0, 0.01));
    } else if constexpr (std::same_as<Definition, Pixel_Visual>) {
        label = "生成三维像素";
        fields.push_back(number_field("size_min", "像素边长下界", "方形像素边长下界，单位为屏幕像素。", 1.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("size_max", "像素边长上界", "方形像素边长上界，单位为屏幕像素。", 6.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Marker_Visual>) {
        label = "生成三维标记";
        fields.push_back(number_field("diameter_min", "标记直径下界", "标记直径下界，单位为屏幕像素。", 4.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("diameter_max", "标记直径上界", "标记直径上界，单位为屏幕像素。", 18.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Sphere_Visual>) {
        label = "生成三维球体";
        fields.push_back(number_field("radius_min", "球体半径下界", "球体半径下界，使用 Scene 坐标。", 0.01, 0.0001, 1000.0, 0.001));
        fields.push_back(number_field("radius_max", "球体半径上界", "球体半径上界，使用 Scene 坐标。", 0.08, 0.0001, 1000.0, 0.001));
    } else if constexpr (std::same_as<Definition, Segment_Visual>) {
        label = "生成三维线段"; description = "起点和终点分别在各轴范围内随机生成。";
        fields.push_back(number_field("width_min", "线宽下界", "线段宽度下界，单位为屏幕像素。", 1.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("width_max", "线宽上界", "线段宽度上界，单位为屏幕像素。", 5.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Vector_Visual>) {
        label = "生成三维向量"; description = "原点按 Scene 范围随机生成，方向分量使用单独范围。";
        fields.push_back(number_field("direction_min", "方向分量下界", "向量 X/Y/Z 方向分量的随机下界。", -0.3, -1'000'000.0, 1'000'000.0, 0.01));
        fields.push_back(number_field("direction_max", "方向分量上界", "向量 X/Y/Z 方向分量的随机上界。", 0.3, -1'000'000.0, 1'000'000.0, 0.01));
    } else if constexpr (std::same_as<Definition, Primitive_Visual>) label = "生成三维图元顶点";
    else if constexpr (std::same_as<Definition, Mesh_Visual>) label = "生成三维网格顶点";
    else if constexpr (std::same_as<Definition, Path_Visual>) {
        label = "生成三维路径顶点";
        fields.push_back(number_field("width_min", "路径宽度下界", "路径宽度下界，单位为屏幕像素。", 1.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("width_max", "路径宽度上界", "路径宽度上界，单位为屏幕像素。", 5.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Image_Visual>) {
        label = "生成三维图像实例";
        fields.push_back(number_field("extent_min", "图像尺寸下界", "图像宽高的 Scene 坐标下界。", 0.02, 0.0001, 1000.0, 0.001));
        fields.push_back(number_field("extent_max", "图像尺寸上界", "图像宽高的 Scene 坐标上界。", 0.2, 0.0001, 1000.0, 0.001));
    } else if constexpr (std::same_as<Definition, Labels_Visual>) {
        label = "生成三维标签实例";
        fields.push_back(number_field("extent_min", "标签尺寸下界", "标签宽高的屏幕像素下界。", 8.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("extent_max", "标签尺寸上界", "标签宽高的屏幕像素上界。", 48.0, 0.1, 4096.0, 0.1));
    } else if constexpr (std::same_as<Definition, Glyph_Visual>) {
        label = "生成三维字形实例";
        fields.push_back(number_field("angle_min", "字形旋转下界", "字形旋转角下界，单位为弧度。", -3.14159, -1000.0, 1000.0, 0.01));
        fields.push_back(number_field("angle_max", "字形旋转上界", "字形旋转角上界，单位为弧度。", 3.14159, -1000.0, 1000.0, 0.01));
    } else if constexpr (std::same_as<Definition, Text_Visual>) {
        label = "生成三维文本实例";
        fields.push_back(number_field("size_min", "字号下界", "随机文本字号下界，单位为屏幕像素。", 10.0, 0.1, 4096.0, 0.1));
        fields.push_back(number_field("size_max", "字号上界", "随机文本字号上界，单位为屏幕像素。", 28.0, 0.1, 4096.0, 0.1));
    }
    return {{"label", std::move(label)}, {"description", std::move(description)}, {"fields", std::move(fields)}};
}

double input_number(const Json& input, std::string_view key) {
    const auto& value = input.at(key);
    if (!value.is_number()) throw std::invalid_argument(std::string(key) + " must be a number");
    const auto result = value.get<double>();
    if (!std::isfinite(result)) throw std::invalid_argument(std::string(key) + " must be finite");
    return result;
}

std::size_t input_count(const Json& input, std::string_view key, std::size_t maximum = 1'000'000) {
    const auto value = input_number(input, key);
    if (value < 1.0 || value > static_cast<double>(maximum) || std::floor(value) != value)
        throw std::invalid_argument(std::string(key) + " is outside the supported integer range");
    return static_cast<std::size_t>(value);
}

std::pair<float, float> input_range(const Json& input, std::string_view minimum_key,
                                    std::string_view maximum_key) {
    const auto minimum = input_number(input, minimum_key);
    const auto maximum = input_number(input, maximum_key);
    if (minimum >= maximum) throw std::invalid_argument(std::string(maximum_key) + " must be greater than " + std::string(minimum_key));
    if (minimum < -std::numeric_limits<float>::max() || maximum > std::numeric_limits<float>::max())
        throw std::invalid_argument("generator range exceeds float coordinates");
    return {static_cast<float>(minimum), static_cast<float>(maximum)};
}

template <typename Definition>
class Item_Randomizer {
public:
    explicit Item_Randomizer(const Json& input) {
        const auto [x_min, x_max] = input_range(input, "x_min", "x_max");
        const auto [y_min, y_max] = input_range(input, "y_min", "y_max");
        const auto [z_min, z_max] = input_range(input, "z_min", "z_max");
        x = std::uniform_real_distribution<float>(x_min, x_max);
        y = std::uniform_real_distribution<float>(y_min, y_max);
        z = std::uniform_real_distribution<float>(z_min, z_max);
        const auto set_first = [&](std::string_view minimum, std::string_view maximum) {
            const auto [lower, upper] = input_range(input, minimum, maximum);
            first = std::uniform_real_distribution<float>(lower, upper);
        };
        const auto set_second = [&](std::string_view minimum, std::string_view maximum) {
            const auto [lower, upper] = input_range(input, minimum, maximum);
            second = std::uniform_real_distribution<float>(lower, upper);
        };
        if constexpr (std::same_as<Definition, Point_Visual> || std::same_as<Definition, Marker_Visual>) set_first("diameter_min", "diameter_max");
        else if constexpr (std::same_as<Definition, Splat_Visual>) { set_first("sigma_min", "sigma_max"); set_second("angle_min", "angle_max"); }
        else if constexpr (std::same_as<Definition, Pixel_Visual> || std::same_as<Definition, Text_Visual>) set_first("size_min", "size_max");
        else if constexpr (std::same_as<Definition, Sphere_Visual>) set_first("radius_min", "radius_max");
        else if constexpr (std::same_as<Definition, Segment_Visual> || std::same_as<Definition, Path_Visual>) set_first("width_min", "width_max");
        else if constexpr (std::same_as<Definition, Vector_Visual>) set_first("direction_min", "direction_max");
        else if constexpr (std::same_as<Definition, Image_Visual> || std::same_as<Definition, Labels_Visual>) set_first("extent_min", "extent_max");
        else if constexpr (std::same_as<Definition, Glyph_Visual>) set_first("angle_min", "angle_max");
    }
    void operator()(typename Definition::Item& item, std::mt19937_64& engine) {
        const auto vector = [&] { return Vec3{x(engine), y(engine), z(engine)}; };
    if constexpr (requires { item.position = vector(); }) item.position = vector();
    else if constexpr (requires { item.center = vector(); }) item.center = vector();
    else if constexpr (requires { item.origin = vector(); }) item.origin = vector();
    else if constexpr (requires { item.start = vector(); item.end = vector(); }) { item.start = vector(); item.end = vector(); }
    if constexpr (std::same_as<Definition, Point_Visual>) item.diameter_px = first(engine);
    else if constexpr (std::same_as<Definition, Splat_Visual>) {
        item.sigma = {first(engine), first(engine)};
        item.angle = second(engine);
    } else if constexpr (std::same_as<Definition, Pixel_Visual>) item.size_px = first(engine);
    else if constexpr (std::same_as<Definition, Marker_Visual>) item.diameter_px = first(engine);
    else if constexpr (std::same_as<Definition, Sphere_Visual>) item.radius = first(engine);
    else if constexpr (std::same_as<Definition, Segment_Visual>) item.width_px = first(engine);
    else if constexpr (std::same_as<Definition, Vector_Visual>) {
        item.direction = {first(engine), first(engine), first(engine)};
    } else if constexpr (std::same_as<Definition, Path_Visual>) item.width_px = first(engine);
    else if constexpr (std::same_as<Definition, Image_Visual> || std::same_as<Definition, Labels_Visual>)
        item.extent = {first(engine), first(engine)};
    else if constexpr (std::same_as<Definition, Glyph_Visual>) item.angle = first(engine);
    else if constexpr (std::same_as<Definition, Text_Visual>) item.size_px = first(engine);
    }
private:
    std::uniform_real_distribution<float> x{};
    std::uniform_real_distribution<float> y{};
    std::uniform_real_distribution<float> z{};
    std::uniform_real_distribution<float> first{};
    std::uniform_real_distribution<float> second{};
};

struct Random_Data_Generator {};

template <typename Visual_Object, typename Data_Generator = Random_Data_Generator>
class Visual_Scene_View final : public Plot::Scene_View {
public:
    using Camera_Object = Impl<Camera_3D>;
    using Axes_Object = Impl<Axes_3D>;
    using Marker_Object = Impl<Marker_Visual>;
    Visual_Scene_View(Scene_3D& scene, std::unique_ptr<Camera_Object> camera,
                      std::unique_ptr<Axes_Object> axes,
                      std::unique_ptr<Visual_Object> visual, std::string label,
                      Data_Generator data_generator = {},
                      std::unique_ptr<Marker_Object> markers = {})
        : data_generator_(std::move(data_generator)), camera_(std::move(camera)),
          axes_(std::move(axes)), visual_(std::move(visual)), markers_(std::move(markers)) {
        using Definition = typename Visual_Object::Attached_Object;
        using Prop = typename Definition::Prop;
        using State = typename Definition::State;
        using Scene_Adapter = detail::Renderable_Adapter<Scene_3D,
            detail::Prop_Field<&Render_Scene_3D::Prop::clear_color, "clear_color", "Linear scene clear color.">,
            detail::Prop_Field<&Render_Scene_3D::Prop::view_active, "view_active", "Whether the scene publishes rendered frames.">,
            detail::State_Field<Scene::Base_Tag, &Scene::State::renderable_count, "renderable_count", "Number of renderables attached to the scene.">,
            detail::State_Field<Scene::Base_Tag, &Scene::State::taskflow_task_count, "taskflow_task_count", "Number of tasks in the scene graph.">,
            detail::State_Field<Scene::Base_Tag, &Scene::State::taskflow_execution_time_ns, "taskflow_execution_time_ns", "Scene graph execution time in nanoseconds.">>;
        using Visual_Adapter = detail::Renderable_Adapter<Visual_Object,
            detail::Prop_Field<&Prop::transform, "transform", "World transform applied to the complete visual.">,
            detail::Prop_Field<&Prop::visible, "visible", "Whether the visual participates in rendering.">,
            detail::Prop_Field<&Prop::depth_test, "depth_test", "Whether fragments use depth testing.">,
            detail::State_Field<Definition::Base_Tag, &State::item_count, "item_count", "Number of published input items.">,
            detail::State_Field<Definition::Base_Tag, &State::prepared_item_count, "prepared_item_count", "Number of prepared backend items.">,
            detail::State_Field<Definition::Base_Tag, &State::prepared_revision, "prepared_revision", "Property revision represented by prepared GPU data.">>;
        using Camera_Adapter = detail::Renderable_Adapter<Camera_Object,
            detail::Prop_Field<&Camera_3D::Prop::initial_view, "initial_view", "Initial eye, target and world-up vectors used by reset view.">,
            detail::Prop_Field<&Camera_3D::Prop::projection, "projection", "Perspective or orthographic camera projection.">,
            detail::Prop_Field<&Camera_3D::Prop::controller, "controller", "Datoviz native camera controller: turntable, arcball, fly or panzoom.">,
            detail::Prop_Field<&Camera_3D::Prop::turntable_control, "turntable_control", "Turntable orbit, zoom and pan speeds and limits.">,
            detail::Prop_Field<&Camera_3D::Prop::arcball_control, "arcball_control", "Arcball free rotation and optional constraint axis.">,
            detail::Prop_Field<&Camera_3D::Prop::fly_control, "fly_control", "Fly camera movement mode, keyboard speed and pointer look settings.">,
            detail::Prop_Field<&Camera_3D::Prop::panzoom_control, "panzoom_control", "Planar panzoom axis locks and aspect-ratio policy.">,
            detail::Prop_Field<&Camera_3D::Prop::vertical_field_of_view_degrees, "vertical_field_of_view_degrees", "Vertical field of view in degrees.">,
            detail::Prop_Field<&Camera_3D::Prop::near_plane, "near_plane", "Nearest visible camera distance.">,
            detail::Prop_Field<&Camera_3D::Prop::far_plane, "far_plane", "Farthest visible camera distance.">>;
        using Axes_Adapter = detail::Renderable_Adapter<Axes_Object,
            detail::Prop_Field<&Axes_3D::Prop::x_axis, "x_axis", "X axis range, scale, ticks, label and unit.">,
            detail::Prop_Field<&Axes_3D::Prop::y_axis, "y_axis", "Y axis range, scale, ticks, label and unit.">,
            detail::Prop_Field<&Axes_3D::Prop::z_axis, "z_axis", "Z axis range, scale, ticks, label and unit.">>;
        descriptors_.push_back(detail::make_renderable_descriptor("scene", "3D 场景", "scene", Scene_Adapter{scene}));
        descriptors_.push_back(detail::make_renderable_descriptor("camera", "相机控制", "camera", Camera_Adapter{*camera_}));
        descriptors_.push_back(detail::make_renderable_descriptor("axes", "三维坐标轴", "axes", Axes_Adapter{*axes_}));
        if constexpr (std::same_as<Definition, Marker_Visual>) {
            using Marker_Adapter = detail::Renderable_Adapter<Visual_Object,
                detail::Prop_Field<&Prop::items, "items", "Marker collection; editing the collection adds, moves or removes actual Scene markers.">,
                detail::Prop_Field<&Prop::transform, "transform", "World transform applied to the complete marker collection.">,
                detail::Prop_Field<&Prop::visible, "visible", "Whether markers participate in rendering.">,
                detail::Prop_Field<&Prop::depth_test, "depth_test", "Whether marker fragments use depth testing.">,
                detail::State_Field<Definition::Base_Tag, &State::item_count, "item_count", "Number of markers in the Scene.">,
                detail::State_Field<Definition::Base_Tag, &State::prepared_item_count, "prepared_item_count", "Number of prepared marker items.">,
                detail::State_Field<Definition::Base_Tag, &State::prepared_revision, "prepared_revision", "Marker GPU data revision.">>;
            descriptors_.push_back(detail::make_renderable_descriptor(
                "visual", std::move(label), "marker", Marker_Adapter{*visual_}));
        } else {
            descriptors_.push_back(detail::make_renderable_descriptor(
                "visual", std::move(label), "visual", Visual_Adapter{*visual_}));
        }
        if (markers_) {
            using Marker_Prop = Marker_Visual::Prop;
            using Marker_State = Marker_Visual::State;
            using Marker_Adapter = detail::Renderable_Adapter<Marker_Object,
                detail::Prop_Field<&Marker_Prop::items, "items", "Surface marker anchors; X and Y are editable while Z is derived from the current spectrogram surface.", "surface-marker-list">,
                detail::Prop_Field<&Marker_Prop::visible, "visible", "Whether the spectrogram marker layer is visible.">,
                detail::Prop_Field<&Marker_Prop::depth_test, "depth_test", "Whether markers may be occluded by the surface.">,
                detail::State_Field<Marker_Visual::Base_Tag, &Marker_State::item_count, "item_count", "Number of spectrogram markers.">,
                detail::State_Field<Marker_Visual::Base_Tag, &Marker_State::prepared_item_count, "prepared_item_count", "Number of markers prepared for Datoviz.">,
                detail::State_Field<Marker_Visual::Base_Tag, &Marker_State::prepared_revision, "prepared_revision", "Marker GPU data revision.">>;
            descriptors_.push_back(detail::make_renderable_descriptor(
                "markers", "频谱标记", "marker", Marker_Adapter{*markers_}));
        }
    }

    [[nodiscard]] nlohmann::json schema() const override {
        nlohmann::json components = nlohmann::json::array();
        for (const auto& descriptor : descriptors_) components.push_back(descriptor->schema());
        return {{"protocol", "aethera.plot.inspector"}, {"version", 2}, {"components", std::move(components)}};
    }

    [[nodiscard]] nlohmann::json write_prop(std::string_view component, std::string_view key, const nlohmann::json& value) override {
        const auto found = std::ranges::find_if(descriptors_, [&](const auto& descriptor) { return descriptor->id() == component; });
        if (found == descriptors_.end()) return {{"success", false}, {"error", "unknown component"}};
        auto result = (*found)->write_prop(key, value);
        result["component"] = component;
        return result;
    }

    [[nodiscard]] nlohmann::json data_generator_schema() const override {
        if constexpr (std::same_as<Data_Generator, Random_Data_Generator>) {
            using Definition = typename Visual_Object::Attached_Object;
            return generator_schema<Definition>();
        } else {
            return data_generator_.schema();
        }
    }

    [[nodiscard]] nlohmann::json generate_data(const nlohmann::json& input) override {
        if constexpr (!std::same_as<Data_Generator, Random_Data_Generator>) {
            return data_generator_.generate(*visual_, *axes_, input);
        } else {
        using Definition = typename Visual_Object::Attached_Object;
        using Prop = typename Definition::Prop;
        using Items = std::remove_cvref_t<decltype(std::declval<Prop>().items)>;
        try {
            std::mt19937_64 engine{input_count(input, "seed", 4'294'967'295ULL)};
            Items generated;
            std::size_t count{};
            if constexpr (std::same_as<Definition, Volume_Visual>) {
                const auto width = input_count(input, "width", 256);
                const auto height = input_count(input, "height", 256);
                const auto depth = input_count(input, "depth", 256);
                if (width > 1'000'000 / height || width * height > 1'000'000 / depth)
                    throw std::invalid_argument("volume dimensions exceed 1,000,000 voxels");
                count = width * height * depth;
                const auto [minimum, maximum] = input_range(input, "value_min", "value_max");
                std::uniform_real_distribution<float> distribution(minimum, maximum);
                generated.resize(count);
                for (auto& item : generated) item.value = distribution(engine);
                visual_->template update_prop<&Prop::items>([&](auto props) {
                    auto& prop = props.template get<typename Definition::Base_Tag>();
                    prop.field_width = static_cast<std::uint32_t>(width);
                    prop.field_height = static_cast<std::uint32_t>(height);
                    prop.field_depth = static_cast<std::uint32_t>(depth);
                });
            } else {
                count = input_count(input, "count", 5'000'000);
                const auto& current = visual_->template read_prop<typename Definition::Base_Tag>().items;
                if (current.empty()) throw std::invalid_argument("visual has no item template");
                const auto prototype = current.front();
                Item_Randomizer<Definition> randomize(input);
                generated.reserve(count);
                for (std::size_t index = 0; index < count; ++index) {
                    auto item = prototype;
                    randomize(item, engine);
                    generated.push_back(std::move(item));
                }
            }
            if (visual_->update_items(std::move(generated)) != Definition::Update_Items_Result::updated)
                throw std::invalid_argument("generated items were rejected by the Visual validator");
            return {{"success", true}, {"generated_count", count}};
        } catch (const std::exception& error) {
            return {{"success", false}, {"error", error.what()}};
        }
        }
    }

    void update(const Plot_Frame_Request& request) override {
        if constexpr (requires(Data_Generator& generator, Visual_Object& visual,
                               Axes_Object& axes, Marker_Object* markers,
                               const Plot_Frame_Request& frame) {
                          generator.update(visual, axes, markers, frame);
                      }) {
            data_generator_.update(*visual_, *axes_, markers_.get(), request);
        }
    }

private:
    [[no_unique_address]] Data_Generator data_generator_;                /* Plot 业务数据生成策略。 */
    std::unique_ptr<Camera_Object> camera_;                              /* Scene 引用的 Camera 唯一所有者。 */
    std::unique_ptr<Axes_Object> axes_;                                  /* Scene 引用的 Axes 唯一所有者。 */
    std::unique_ptr<Visual_Object> visual_;                              /* Scene 引用的 Visual 唯一所有者。 */
    std::unique_ptr<Marker_Object> markers_;                             /* 可选的独立 Marker Visual 所有者。 */
    std::vector<std::unique_ptr<detail::Renderable_Descriptor>> descriptors_; /* Prop/State 协议描述。 */
};

struct Scene_Components_3D {
    plot::Camera_Descriptor camera{};
    std::array<plot::Axis_Descriptor, 3> axes{
        plot::Axis_Descriptor{{-1.0, 1.0}, plot::Axis_Scale::linear, "X", "", 5, 2, true, true, true},
        plot::Axis_Descriptor{{-1.0, 1.0}, plot::Axis_Scale::linear, "Y", "", 5, 2, true, true, true},
        plot::Axis_Descriptor{{-1.0, 1.0}, plot::Axis_Scale::linear, "Z", "", 5, 2, true, true, true}};
};

template <typename Definition, typename Build_Result,
          typename Data_Generator = Random_Data_Generator>
std::shared_ptr<Plot> make_visual_plot(asio::any_io_executor executor, std::string label,
                                      Build_Result build_result,
                                      Scene_Components_3D components = {},
                                      Data_Generator data_generator = {},
                                      std::unique_ptr<Impl<Marker_Visual>> markers = {}) {
    using Visual_Object = Impl<Definition>;
    using Camera_Object = Impl<Camera_3D>;
    using Axes_Object = Impl<Axes_3D>;
    if (!build_result) throw std::logic_error("3D Gallery visual dependency graph is invalid");
    auto visual = std::move(build_result).value();
    auto camera_result = Camera_Object::Builder{}
        .set(&Camera_3D::Prop::initial_view, components.camera.initial_view)
        .set(&Camera_3D::Prop::projection, components.camera.projection)
        .set(&Camera_3D::Prop::controller, components.camera.controller)
        .set(&Camera_3D::Prop::turntable_control, components.camera.turntable_control)
        .set(&Camera_3D::Prop::arcball_control, components.camera.arcball_control)
        .set(&Camera_3D::Prop::fly_control, components.camera.fly_control)
        .set(&Camera_3D::Prop::panzoom_control, components.camera.panzoom_control)
        .set(&Camera_3D::Prop::vertical_field_of_view_degrees,
             components.camera.vertical_field_of_view_degrees)
        .set(&Camera_3D::Prop::near_plane, components.camera.near_plane)
        .set(&Camera_3D::Prop::far_plane, components.camera.far_plane)
        .build();
    auto axes_result = Axes_Object::Builder{}
        .set(&Axes_3D::Prop::x_axis, components.axes[0])
        .set(&Axes_3D::Prop::y_axis, components.axes[1])
        .set(&Axes_3D::Prop::z_axis, components.axes[2])
        .build();
    if (!camera_result || !axes_result)
        throw std::logic_error("3D Gallery component construction failed");
    auto camera = std::move(camera_result).value();
    auto axes = std::move(axes_result).value();
    auto scene_builder = Scene_3D::Builder{};
    scene_builder.add_camera(camera.get())
        .add_axes(axes.get())
        .add_renderable(visual.get())
        .set(&Render_Scene_3D::Prop::viewport, Extent{720, 420})
        .set(&Render_Scene_3D::Prop::clear_color, Linear_Color{0.018F, 0.027F, 0.047F, 1.0F})
        .set(&Render_Scene_3D::Prop::view_active, true);
    if (markers) scene_builder.add_renderable(markers.get());
    auto scene_result = scene_builder.build();
    if (!scene_result) throw std::logic_error("3D Gallery scene dependency graph is invalid");
    auto scene = std::move(scene_result).value();
    auto view = std::make_unique<Visual_Scene_View<Visual_Object, Data_Generator>>(
        *scene, std::move(camera), std::move(axes), std::move(visual),
        std::move(label), std::move(data_generator), std::move(markers));
    return std::make_shared<Plot>(std::move(executor), std::move(scene), std::move(view));
}

Color color(std::uint8_t red, std::uint8_t green, std::uint8_t blue, std::uint8_t alpha = 255) {
    return {red, green, blue, alpha};
}

struct Spectrogram_Parameters {
    std::size_t time_sample_count{80};
    std::size_t frequency_bin_count{96};
    std::size_t ridge_count{5};
    double time_span_seconds{4.0};
    double minimum_frequency_hz{10.0};
    double maximum_frequency_hz{20'000.0};
    double minimum_level_db{18.0};
    double maximum_level_db{78.0};
    double animation_speed{1.0};
    std::size_t update_every_n_frames{1};
    bool animation_enabled{true};
};

Color spectrogram_color(float value) {
    struct Stop { float position; std::array<float, 3> rgb; };
    static constexpr std::array stops{
        Stop{0.0F, {22, 10, 54}}, Stop{0.22F, {76, 18, 112}},
        Stop{0.45F, {151, 40, 103}}, Stop{0.68F, {226, 83, 61}},
        Stop{0.86F, {252, 169, 52}}, Stop{1.0F, {252, 246, 164}}};
    value = std::clamp(value, 0.0F, 1.0F);
    for (std::size_t index = 1; index < stops.size(); ++index) {
        if (value > stops[index].position) continue;
        const auto& lower = stops[index - 1];
        const auto& upper = stops[index];
        const auto ratio = (value - lower.position) /
                           (upper.position - lower.position);
        const auto channel = [&](std::size_t component) {
            return static_cast<std::uint8_t>(std::lround(
                std::lerp(lower.rgb[component], upper.rgb[component], ratio)));
        };
        return color(channel(0), channel(1), channel(2));
    }
    return color(252, 246, 164);
}

Vec3 face_normal(Vec3 first, Vec3 second, Vec3 third) {
    const Vec3 a{second.x - first.x, second.y - first.y, second.z - first.z};
    const Vec3 b{third.x - first.x, third.y - first.y, third.z - first.z};
    Vec3 result{a.y * b.z - a.z * b.y,
                a.z * b.x - a.x * b.z,
                a.x * b.y - a.y * b.x};
    const auto length = std::sqrt(result.x * result.x + result.y * result.y +
                                  result.z * result.z);
    if (!(length > 0.0F)) return {0, 0, 1};
    result.x /= length;
    result.y /= length;
    result.z /= length;
    return result;
}

float spectrogram_level(float time, float frequency, double animation_seconds,
                        std::size_t ridge_count) {
    struct Ridge { float center; float width; float phase; float speed; float strength; };
    static constexpr std::array ridges{
        Ridge{0.12F, 0.035F, 0.20F, 0.42F, 0.72F},
        Ridge{0.28F, 0.060F, 1.45F, 0.67F, 0.58F},
        Ridge{0.47F, 0.045F, 2.70F, 0.53F, 0.82F},
        Ridge{0.68F, 0.075F, 4.10F, 0.31F, 0.52F},
        Ridge{0.84F, 0.030F, 5.20F, 0.78F, 0.68F},
        Ridge{0.57F, 0.022F, 0.90F, 1.05F, 0.44F},
        Ridge{0.36F, 0.028F, 3.60F, 0.91F, 0.40F},
        Ridge{0.76F, 0.050F, 2.10F, 0.58F, 0.46F},
        Ridge{0.20F, 0.024F, 4.80F, 0.72F, 0.38F},
        Ridge{0.92F, 0.020F, 1.90F, 0.84F, 0.36F},
        Ridge{0.52F, 0.090F, 5.70F, 0.27F, 0.32F},
        Ridge{0.08F, 0.018F, 3.00F, 1.12F, 0.30F}};
    const float animation = static_cast<float>(animation_seconds);
    float level = 0.075F + 0.055F * std::sin(
        2.0F * std::numbers::pi_v<float> *
        (0.78F * time + 0.24F * frequency + 0.11F * animation));
    const auto active_ridges = std::min(ridge_count, ridges.size());
    for (std::size_t index = 0; index < active_ridges; ++index) {
        const auto& ridge = ridges[index];
        const auto moving_center = std::clamp(
            ridge.center + 0.065F * std::sin(
                ridge.phase + ridge.speed * animation + 1.3F * time),
            0.015F, 0.985F);
        const auto distance = (frequency - moving_center) / ridge.width;
        const auto envelope = 0.52F + 0.48F * std::sin(
            ridge.phase * 0.61F + 2.2F * time +
            (ridge.speed + 0.18F) * animation);
        level += ridge.strength * envelope * std::exp(-0.5F * distance * distance);
    }
    const float detail = 0.025F * std::sin(
        31.0F * frequency + 8.0F * time + 1.7F * animation) +
                         0.018F * std::cos(
                             19.0F * frequency - 13.0F * time + animation);
    return std::clamp(level + detail, 0.0F, 1.0F);
}

std::vector<Mesh_Vertex> spectrogram_mesh(const Spectrogram_Parameters& parameters,
                                          double animation_seconds = 0.0) {

    struct Sample { Vec3 position; Color color; };
    std::vector<Sample> samples(parameters.time_sample_count *
                                parameters.frequency_bin_count);
    for (std::size_t time_index = 0; time_index < parameters.time_sample_count;
         ++time_index) {
        const auto time = static_cast<float>(time_index) /
                          static_cast<float>(parameters.time_sample_count - 1);
        for (std::size_t frequency_index = 0;
             frequency_index < parameters.frequency_bin_count; ++frequency_index) {
            const auto frequency = static_cast<float>(frequency_index) /
                                   static_cast<float>(parameters.frequency_bin_count - 1);
            const float level = spectrogram_level(
                time, frequency, animation_seconds, parameters.ridge_count);
            samples[time_index * parameters.frequency_bin_count + frequency_index] = {
                {-1.0F + 2.0F * time, -1.0F + 2.0F * frequency,
                 -1.0F + 2.0F * level}, spectrogram_color(level)};
        }
    }

    std::vector<Mesh_Vertex> mesh;
    mesh.reserve((parameters.time_sample_count - 1) *
                 (parameters.frequency_bin_count - 1) * 6);
    const auto append_triangle = [&](const Sample& first, const Sample& second,
                                     const Sample& third) {
        const auto normal = face_normal(first.position, second.position, third.position);
        mesh.push_back({first.position, first.color, normal, {0, 0}});
        mesh.push_back({second.position, second.color, normal, {0, 0}});
        mesh.push_back({third.position, third.color, normal, {0, 0}});
    };
    for (std::size_t time_index = 0; time_index + 1 < parameters.time_sample_count;
         ++time_index) {
        for (std::size_t frequency_index = 0;
             frequency_index + 1 < parameters.frequency_bin_count; ++frequency_index) {
            const auto current = time_index * parameters.frequency_bin_count + frequency_index;
            const auto next_time = current + parameters.frequency_bin_count;
            append_triangle(samples[current], samples[next_time], samples[next_time + 1]);
            append_triangle(samples[current], samples[next_time + 1], samples[current + 1]);
        }
    }
    return mesh;
}

struct Spectrogram_Data_Generator {
    Spectrogram_Parameters parameters{};

    explicit Spectrogram_Data_Generator(Spectrogram_Parameters value = {})
        : parameters(std::move(value)) {}

    [[nodiscard]] Json schema() const {
        Json fields = Json::array();
        fields.push_back(integer_field("time_sample_count", "时间采样数", "时间方向网格采样数；GPU 顶点数约为 6×(时间采样数-1)×(频率分箱数-1)。", parameters.time_sample_count, 16, 1024));
        fields.push_back(integer_field("frequency_bin_count", "频率分箱数", "对数频率方向分箱数；与时间采样数共同决定三角形和每次上传的数据量。", parameters.frequency_bin_count, 16, 1024));
        fields.push_back(integer_field("ridge_count", "谱峰轨迹数", "生成随时间漂移的窄带谱峰数量。", 5, 1, 12));
        fields.push_back(number_field("time_span_seconds", "时间跨度", "X 轴时间范围，单位秒。", parameters.time_span_seconds, 0.1, 3600.0, 0.1));
        fields.push_back(number_field("minimum_frequency_hz", "最低频率", "对数频率轴下界，必须大于零。", parameters.minimum_frequency_hz, 0.001, 1.0e12, 1.0));
        fields.push_back(number_field("maximum_frequency_hz", "最高频率", "对数频率轴上界，必须大于最低频率。", parameters.maximum_frequency_hz, 0.002, 1.0e12, 10.0));
        fields.push_back(number_field("minimum_level_db", "最低声压级", "Z 轴色阶与高度下界，单位 dB。", parameters.minimum_level_db, -1000.0, 1000.0, 1.0));
        fields.push_back(number_field("maximum_level_db", "最高声压级", "Z 轴色阶与高度上界，必须大于下界。", parameters.maximum_level_db, -1000.0, 1000.0, 1.0));
        fields.push_back(number_field("animation_speed", "动态速度倍率", "谱峰随时间运动的倍率；0 表示保持当前相位。", parameters.animation_speed, 0.0, 100.0, 0.1));
        fields.push_back(integer_field("update_every_n_frames", "数据更新帧间隔", "每 N 个渲染请求重建并上传一次 Mesh；可分离固定几何绘制与持续数据上传压力。", parameters.update_every_n_frames, 1, 10'000));
        fields.push_back({{"key", "animation_enabled"}, {"label", "持续生成动态数据"}, {"description", "关闭后保留生成的数据集，仅测试固定 Mesh 的重复绘制；开启后按更新间隔持续重建。"}, {"editor", "boolean"}, {"editable", true}, {"value", parameters.animation_enabled}});
        return {{"label", "生成三维频谱瀑布"},
                {"description", "按时间采样、对数频率分箱和声压级范围生成连续 GPU Mesh 表面。"},
                {"fields", std::move(fields)}};
    }

    [[nodiscard]] Json generate(Impl<Mesh_Visual>& visual, Impl<Axes_3D>& axes,
                                const Json& input) {
        try {
            Spectrogram_Parameters next;
            next.time_sample_count = input_count(input, "time_sample_count", 1024);
            next.frequency_bin_count = input_count(input, "frequency_bin_count", 1024);
            next.ridge_count = input_count(input, "ridge_count", 12);
            next.time_span_seconds = input_number(input, "time_span_seconds");
            next.minimum_frequency_hz = input_number(input, "minimum_frequency_hz");
            next.maximum_frequency_hz = input_number(input, "maximum_frequency_hz");
            next.minimum_level_db = input_number(input, "minimum_level_db");
            next.maximum_level_db = input_number(input, "maximum_level_db");
            next.animation_speed = input_number(input, "animation_speed");
            next.update_every_n_frames = input_count(input, "update_every_n_frames", 10'000);
            const auto animation = input.at("animation_enabled");
            if (!animation.is_boolean()) throw std::invalid_argument("animation_enabled must be boolean");
            next.animation_enabled = animation.get<bool>();
            if (!(next.time_span_seconds > 0.0) ||
                !(next.minimum_frequency_hz > 0.0) ||
                !(next.maximum_frequency_hz > next.minimum_frequency_hz) ||
                !(next.maximum_level_db > next.minimum_level_db))
                throw std::invalid_argument("spectrogram ranges are invalid");
            const auto cells = (next.time_sample_count - 1) * (next.frequency_bin_count - 1);
            if (cells > 1'400'000)
                throw std::invalid_argument("spectrogram exceeds the 8,400,000 vertex stress-test limit");
            parameters = next;
            auto mesh = spectrogram_mesh(parameters);
            const auto vertex_count = mesh.size();
            if (visual.update_items(std::move(mesh)) != Mesh_Visual::Update_Items_Result::updated)
                throw std::invalid_argument("generated spectrogram mesh was rejected");
            plot::Axis_Descriptor time_axis{{0.0, parameters.time_span_seconds},
                plot::Axis_Scale::time, "Time", "s", 6, 1, true, true, true};
            plot::Axis_Descriptor frequency_axis{{parameters.minimum_frequency_hz,
                parameters.maximum_frequency_hz}, plot::Axis_Scale::logarithmic,
                "Frequency", "Hz", 5, 0, true, true, true};
            plot::Axis_Descriptor level_axis{{parameters.minimum_level_db,
                parameters.maximum_level_db}, plot::Axis_Scale::linear,
                "SPL", "dB", 7, 0, true, true, true};
            axes.set<&Axes_3D::Prop::x_axis>(std::move(time_axis));
            axes.set<&Axes_3D::Prop::y_axis>(std::move(frequency_axis));
            axes.set<&Axes_3D::Prop::z_axis>(std::move(level_axis));
            return {{"success", true}, {"generated_count", vertex_count},
                    {"triangle_count", vertex_count / 3}};
        } catch (const std::exception& error) {
            return {{"success", false}, {"error", error.what()}};
        }
    }

    void update(Impl<Mesh_Visual>& visual, Impl<Axes_3D>&,
                Impl<Marker_Visual>* markers,
                const Plot_Frame_Request& request) {
        if (!parameters.animation_enabled ||
            request.correlation_id % parameters.update_every_n_frames != 0) return;
        const double animation_seconds = request.time_milliseconds / 1000.0 * parameters.animation_speed;
        auto mesh = spectrogram_mesh(parameters, animation_seconds);
        if (visual.update_items(std::move(mesh)) != Mesh_Visual::Update_Items_Result::updated)
            throw std::logic_error("animated spectrogram mesh was rejected");
        if (markers == nullptr) return;
        auto items = markers->template read_prop<Marker_Visual::Base_Tag>().items;
        for (auto& marker : items) {
            const float time = std::clamp((marker.position.x + 1.0F) * 0.5F, 0.0F, 1.0F);
            const float frequency = std::clamp((marker.position.y + 1.0F) * 0.5F, 0.0F, 1.0F);
            marker.position.z = -1.0F + 2.0F * spectrogram_level(
                time, frequency, animation_seconds, parameters.ridge_count);
        }
        if (markers->update_items(std::move(items)) != Marker_Visual::Update_Items_Result::updated)
            throw std::logic_error("surface-attached spectrogram markers were rejected");
    }
};
}

std::shared_ptr<Plot> make_datoviz_point_plot(asio::any_io_executor executor) {
    return make_visual_plot<Point_Visual>(std::move(executor), "Point Visual", Impl<Point_Visual>::Builder{}
        .set(&Point_Visual::Prop::items, std::vector<Point>{{{-0.65F, -0.25F, 0.05F}, color(255, 91, 110), 28.0F}, {{0.0F, 0.58F, 0.25F}, color(82, 226, 190), 34.0F}, {{0.62F, -0.12F, -0.15F}, color(75, 145, 255), 30.0F}}).build());
}

std::shared_ptr<Plot> make_datoviz_splat_plot(asio::any_io_executor executor) {
    return make_visual_plot<Splat_Visual>(std::move(executor), "Splat Visual", Impl<Splat_Visual>::Builder{}
        .set(&Splat_Visual::Prop::items, std::vector<Splat>{{{-0.48F, 0.0F, 0.1F}, color(255, 98, 115, 210), {0.18F, 0.08F}, 0.45F}, {{0.28F, 0.15F, 0.0F}, color(66, 218, 188, 210), {0.12F, 0.22F}, -0.3F}, {{0.15F, -0.38F, 0.2F}, color(76, 132, 255, 210), {0.2F, 0.1F}, 0.9F}}).build());
}

std::shared_ptr<Plot> make_datoviz_pixel_plot(asio::any_io_executor executor) {
    std::vector<Pixel> pixels;
    for (int y = -8; y <= 8; ++y) for (int x = -12; x <= 12; ++x) pixels.push_back({{x / 13.0F, y / 9.0F, 0.12F * std::sin(x * .45F) * std::cos(y * .35F)}, color(static_cast<std::uint8_t>(90 + 6 * (x + 12)), static_cast<std::uint8_t>(100 + 8 * (y + 8)), 230), 5.0F});
    return make_visual_plot<Pixel_Visual>(std::move(executor), "Pixel Visual", Impl<Pixel_Visual>::Builder{}.set(&Pixel_Visual::Prop::items, std::move(pixels)).build());
}

std::shared_ptr<Plot> make_datoviz_marker_plot(asio::any_io_executor executor) {
    return make_visual_plot<Marker_Visual>(std::move(executor), "Marker Visual", Impl<Marker_Visual>::Builder{}
        .set(&Marker_Visual::Prop::items, std::vector<Marker>{{{-0.7F, 0.0F, 0.0F}, color(255, 93, 115), 34.0F, 0.0F, Marker_Shape::disc}, {{-0.35F, 0.25F, 0.1F}, color(91, 226, 193), 36.0F, 0.25F, Marker_Shape::square}, {{0.0F, -0.2F, 0.2F}, color(100, 158, 255), 38.0F, 0.5F, Marker_Shape::triangle}, {{0.35F, 0.25F, 0.1F}, color(250, 195, 92), 40.0F, 0.75F, Marker_Shape::diamond}, {{0.7F, 0.0F, 0.0F}, color(201, 132, 255), 42.0F, 1.0F, Marker_Shape::cross}}).build());
}

std::shared_ptr<Plot> make_datoviz_sphere_plot(asio::any_io_executor executor) {
    return make_visual_plot<Sphere_Visual>(std::move(executor), "Sphere Visual", Impl<Sphere_Visual>::Builder{}
        .set(&Sphere_Visual::Prop::items, std::vector<Sphere>{{{-0.48F, -0.2F, 0.0F}, color(255, 91, 110), 0.28F}, {{0.08F, 0.25F, 0.18F}, color(82, 226, 190), 0.36F}, {{0.55F, -0.18F, -0.12F}, color(75, 145, 255), 0.24F}}).build());
}

std::shared_ptr<Plot> make_datoviz_segment_plot(asio::any_io_executor executor) {
    std::vector<Segment> segments;
    for (int index = 0; index < 12; ++index) { const float angle = static_cast<float>(index) * std::numbers::pi_v<float> / 6.0F; segments.push_back({{0.0F, 0.0F, 0.0F}, {0.82F * std::cos(angle), 0.82F * std::sin(angle), 0.18F * std::sin(2 * angle)}, color(static_cast<std::uint8_t>(80 + index * 13), static_cast<std::uint8_t>(220 - index * 8), 240), 4.0F}); }
    return make_visual_plot<Segment_Visual>(std::move(executor), "Segment Visual", Impl<Segment_Visual>::Builder{}.set(&Segment_Visual::Prop::items, std::move(segments)).build());
}

std::shared_ptr<Plot> make_datoviz_vector_plot(asio::any_io_executor executor) {
    return make_visual_plot<Vector_Visual>(std::move(executor), "Vector Visual", Impl<Vector_Visual>::Builder{}
        .set(&Vector_Visual::Prop::items, std::vector<Vector_Glyph>{{{-0.55F, -0.35F, 0.0F}, {0.55F, 0.2F, 0.25F}, color(255, 98, 115), 4.0F}, {{-0.1F, 0.0F, 0.0F}, {0.2F, 0.62F, 0.18F}, color(80, 225, 190), 5.0F}, {{0.35F, -0.25F, 0.0F}, {-0.12F, 0.25F, 0.65F}, color(78, 145, 255), 4.0F}}).build());
}

std::shared_ptr<Plot> make_datoviz_primitive_plot(asio::any_io_executor executor) {
    return make_visual_plot<Primitive_Visual>(std::move(executor), "Primitive Visual", Impl<Primitive_Visual>::Builder{}
        .set(&Primitive_Visual::Prop::topology, Primitive_Topology::triangle_list)
        .set(&Primitive_Visual::Prop::items, std::vector<Primitive_Vertex>{{{-0.72F, -0.55F, 0.0F}, color(255, 86, 110), {0, 0, 1}}, {{0.72F, -0.55F, 0.0F}, color(75, 145, 255), {0, 0, 1}}, {{0.0F, 0.72F, 0.25F}, color(82, 226, 190), {0, 0, 1}}}).build());
}

std::shared_ptr<Plot> make_datoviz_mesh_plot(asio::any_io_executor executor) {
    const std::vector<Mesh_Vertex> mesh{{{-0.65F, -0.55F, 0.0F}, color(255, 94, 112), {0, 0, 1}, {0, 0}}, {{0.65F, -0.55F, 0.0F}, color(75, 145, 255), {0, 0, 1}, {1, 0}}, {{0.65F, 0.55F, 0.0F}, color(82, 226, 190), {0, 0, 1}, {1, 1}}, {{-0.65F, -0.55F, 0.0F}, color(255, 94, 112), {0, 0, 1}, {0, 0}}, {{0.65F, 0.55F, 0.0F}, color(82, 226, 190), {0, 0, 1}, {1, 1}}, {{-0.65F, 0.55F, 0.0F}, color(244, 190, 86), {0, 0, 1}, {0, 1}}};
    return make_visual_plot<Mesh_Visual>(std::move(executor), "Mesh Visual", Impl<Mesh_Visual>::Builder{}.set(&Mesh_Visual::Prop::items, mesh).build());
}

std::shared_ptr<Plot> make_datoviz_spectrogram_plot(asio::any_io_executor executor) {
    const Spectrogram_Parameters parameters;
    auto marker_result = Impl<Marker_Visual>::Builder{}
        .set(&Marker_Visual::Prop::items, std::vector<Marker>{
            {{-0.35F, -0.18F, 0.72F}, color(255, 244, 170), 23.0F, 0.0F,
             Marker_Shape::diamond, true},
            {{0.28F, 0.34F, 0.86F}, color(88, 236, 211), 21.0F, 0.0F,
             Marker_Shape::cross, true}})
        .set(&Marker_Visual::Prop::depth_test, false)
        .build();
    if (!marker_result)
        throw std::logic_error("3D Spectrogram marker construction failed");
    auto markers = std::move(marker_result).value();
    Scene_Components_3D components;
    components.camera.initial_view = {{3.35, -3.55, 2.45}, {0.0, 0.0, -0.05},
                                      {0.0, 0.0, 1.0}};
    components.camera.turntable_control = {0.15, 0.15, 0.10, 0.0015,
                                           -1.35, 1.35, 1.25, 12.0,
                                           true, true, true, false};
    components.camera.vertical_field_of_view_degrees = 41.0;
    components.axes = {
        plot::Axis_Descriptor{{0.0, parameters.time_span_seconds},
            plot::Axis_Scale::time, "Time", "s", 6, 1, true, true, true},
        plot::Axis_Descriptor{{parameters.minimum_frequency_hz,
            parameters.maximum_frequency_hz}, plot::Axis_Scale::logarithmic,
            "Frequency", "Hz", 5, 0, true, true, true},
        plot::Axis_Descriptor{{parameters.minimum_level_db,
            parameters.maximum_level_db}, plot::Axis_Scale::linear,
            "SPL", "dB", 7, 0, true, true, true}};
    return make_visual_plot<Mesh_Visual>(
        std::move(executor), "3D Spectrogram",
        Impl<Mesh_Visual>::Builder{}
            .set(&Mesh_Visual::Prop::items, spectrogram_mesh(parameters))
            .build(),
        std::move(components), Spectrogram_Data_Generator{parameters}, std::move(markers));
}

std::shared_ptr<Plot> make_datoviz_path_plot(asio::any_io_executor executor) {
    std::vector<Path_Vertex> path;
    for (int index = 0; index < 64; ++index) { const float t = static_cast<float>(index) / 63.0F; path.push_back({{-0.9F + 1.8F * t, 0.48F * std::sin(t * 4.0F * std::numbers::pi_v<float>), 0.25F * std::cos(t * 2.0F * std::numbers::pi_v<float>)}, color(static_cast<std::uint8_t>(70 + 170 * t), static_cast<std::uint8_t>(220 - 80 * t), 245), 5.0F}); }
    return make_visual_plot<Path_Visual>(std::move(executor), "Path Visual", Impl<Path_Visual>::Builder{}.set(&Path_Visual::Prop::items, std::move(path)).build());
}

std::shared_ptr<Plot> make_datoviz_image_plot(asio::any_io_executor executor) {
    return make_visual_plot<Image_Visual>(std::move(executor), "Image Visual", Impl<Image_Visual>::Builder{}
        .set(&Image_Visual::Prop::field_width, 32U).set(&Image_Visual::Prop::field_height, 32U)
        .set(&Image_Visual::Prop::items, std::vector<Image>{{{0.0F, 0.0F, 0.0F}, {1.45F, 1.0F}, {0, 0, 1, 1}, color(255, 255, 255)}}).build());
}

std::shared_ptr<Plot> make_datoviz_labels_plot(asio::any_io_executor executor) {
    return make_visual_plot<Labels_Visual>(std::move(executor), "Labels Visual", Impl<Labels_Visual>::Builder{}
        .set(&Labels_Visual::Prop::field_width, 8U).set(&Labels_Visual::Prop::field_height, 8U)
        .set(&Labels_Visual::Prop::items, std::vector<Label>{{{-0.55F, 0.28F, 0.0F}, 0, {72, 34}, color(255, 255, 255)}, {{0.5F, 0.25F, 0.1F}, 1, {72, 34}, color(255, 255, 255)}, {{-0.45F, -0.32F, 0.1F}, 2, {72, 34}, color(255, 255, 255)}, {{0.55F, -0.3F, 0.0F}, 3, {72, 34}, color(255, 255, 255)}}).build());
}

std::shared_ptr<Plot> make_datoviz_glyph_plot(asio::any_io_executor executor) {
    return make_visual_plot<Glyph_Visual>(std::move(executor), "Glyph Visual", Impl<Glyph_Visual>::Builder{}
        .set(&Glyph_Visual::Prop::field_width, 32U).set(&Glyph_Visual::Prop::field_height, 32U)
        .set(&Glyph_Visual::Prop::items, std::vector<Glyph>{{{-0.55F, -0.15F, 0.0F}, {-0.18F, -0.18F, 0.18F, 0.18F}, {0, 0, 1, 1}, color(255, 100, 120), -0.2F}, {{0.0F, 0.22F, 0.1F}, {-0.22F, -0.22F, 0.22F, 0.22F}, {0, 0, 1, 1}, color(82, 226, 190), 0.25F}, {{0.55F, -0.15F, 0.0F}, {-0.2F, -0.2F, 0.2F, 0.2F}, {0, 0, 1, 1}, color(80, 145, 255), 0.55F}}).build());
}

std::shared_ptr<Plot> make_datoviz_text_plot(asio::any_io_executor executor) {
    return make_visual_plot<Text_Visual>(std::move(executor), "Text Visual", Impl<Text_Visual>::Builder{}
        .set(&Text_Visual::Prop::items, std::vector<Text_Label>{{{-0.72F, 0.28F, 0.0F}, "Aethera", color(82, 226, 190), 28.0F}, {{-0.62F, -0.15F, 0.1F}, "Datoviz Visual", color(90, 155, 255), 22.0F}}).build());
}

std::shared_ptr<Plot> make_datoviz_volume_plot(asio::any_io_executor executor) {
    std::vector<Voxel> voxels(16U * 16U * 16U);
    for (std::size_t index = 0; index < voxels.size(); ++index) voxels[index].value = static_cast<float>(index % 256U) / 255.0F;
    return make_visual_plot<Volume_Visual>(std::move(executor), "Volume Visual", Impl<Volume_Visual>::Builder{}
        .set(&Volume_Visual::Prop::field_width, 16U).set(&Volume_Visual::Prop::field_height, 16U).set(&Volume_Visual::Prop::field_depth, 16U)
        .set(&Volume_Visual::Prop::items, std::move(voxels)).build());
}
}