Renderive/Core/architecture/Render_Config.h

#pragma once
#include <cstddef>
#include <cstdint>
namespace renderive {
using Plot_Execution_Id = std::uint64_t;
enum class Dirty_Reason : std::uint8_t {
    Core_Data,
    Config,
    Viewport
};
enum class Render_Task_Kind : std::uint8_t {
    Frame,
    Curve,
    Waterfall,
    Primitive,
    Compose,
    Performance
};
struct Render_Runtime_Config {
    std::size_t worker_count{};
};
struct Render_Executor_Snapshot {
    std::size_t worker_count{};
    std::size_t active_workers{};
    std::size_t idle_workers{};
    std::size_t active_frame_jobs{};
    std::size_t queued_frame_jobs{};
    std::uint64_t submitted_topologies{};
    std::uint64_t started_topologies{};
    std::uint64_t completed_topologies{};
    std::uint64_t started_task_nodes{};
    std::uint64_t completed_task_nodes{};
    std::uint64_t rejected_frame_jobs{};
    std::uint64_t dropped_frame_attempts{};
    std::uint64_t peak_concurrency{};
    std::uint64_t average_topology_queue_wait_ns{};
    std::uint64_t max_topology_queue_wait_ns{};
    std::uint64_t average_task_node_duration_ns{};
    std::uint64_t max_task_node_duration_ns{};
    std::uint64_t curve_tasks{};
    std::uint64_t waterfall_tasks{};
    std::uint64_t primitive_tasks{};
    std::uint64_t compose_tasks{};
    std::uint64_t performance_tasks{};
};
struct Frame_Worker_Stats {
    Render_Executor_Snapshot executor_at_submit;
    Render_Executor_Snapshot executor_at_finish;
    std::uint32_t business_task_count{};
    std::uint32_t business_task_peak_parallelism{};
    std::uint64_t topology_queue_wait_total_ns{};
    std::uint64_t topology_queue_wait_max_ns{};
    std::uint64_t business_task_run_total_ns{};
    std::uint64_t topology_run_total_ns{};
    std::uint64_t rejected_topology_count{};
};
enum class Refresh_Limit_Source : std::uint8_t {
    Unknown,
    Input,
    Render,
    Paint,
    User
};
enum class Low_Latency_Limit_Reason : std::uint8_t {
    User_Fps,
    Consumer_Capacity,
    Render_Capacity,
    No_Work,
    Shutdown
};
enum class Low_Latency_Bottleneck_State : std::uint8_t {
    Unknown,
    Input_Limited,
    Producer_Limited,
    Consumer_Limited,
    User_Limited
};
enum class Low_Latency_Production_Mode : std::uint8_t {
    Latency_Eager,
    Consumer_Paced
};
enum class Consumer_Confidence : std::uint8_t {
    Low,
    Medium,
    High
};
enum class Consumer_Sample_Result : std::uint8_t {
    Accepted,
    Rejected_No_Backlog,
    Rejected_Producer_Starved,
    Rejected_No_New_Frame,
    Rejected_Invalid_Timestamp
};
enum class Low_Latency_Feedback_Decision : std::uint8_t {
    Hold_User_Period,
    Enter_Consumer_Paced,
    Exit_Consumer_Paced,
    Reject_Consumer_Sample,
    Producer_Starved
};
struct Consumer_Backlog_Epoch {
    std::uint64_t begin_ns{};
    std::uint64_t end_ns{};
    std::uint32_t rendered_frames{};
    std::uint32_t superseded_frames{};
    bool continuously_backlogged{};
    bool producer_starved{};
};
struct Low_Latency_Performance_Diagnostics {
    std::uint64_t update_posted_count{};
    std::uint64_t duplicate_present_request_suppressed_count{};
    std::uint64_t update_ack_count{};
    std::uint64_t update_repost_count{};
    std::uint64_t consumer_sample_accepted_count{};
    std::uint64_t consumer_sample_rejected_no_backlog_count{};
    std::uint64_t consumer_sample_rejected_starved_count{};
    std::uint64_t consumer_sample_rejected_no_new_frame_count{};
    std::uint64_t consumer_sample_rejected_invalid_timestamp_count{};
    std::uint64_t producer_starvation_count{};
    std::uint64_t mode_enter_count{};
    std::uint64_t mode_exit_count{};
    std::uint64_t middle_published_count{};
    std::uint64_t middle_superseded_count{};
    std::uint64_t painting_advanced_count{};
    std::uint64_t painting_repeated_count{};
    std::uint64_t underrun_count{};
    std::uint64_t paint_without_posted_update_count{};
};
enum class Frame_Outcome : std::uint8_t {
    Presented,
    Superseded,
    Render_Acquire_Dropped,
    Publish_Dropped,
    Paint_Acquire_Dropped,
    Worker_Budget_Dropped,
    Cancelled
};
/// @brief Rendering cache strategy for a renderable subtree.
enum class Renderable_Cache_Mode : std::uint8_t {
    /// @brief Draw directly into the target painter each frame.
    Direct,
    /// @brief Rebuild a local image cache when state changes, then compose it.
    Local_Pixel
};
} // namespace renderive