scirs2_metrics/visualization/advanced_interactive/

rendering.rs

//! Rendering engine for interactive visualization
//!
//! This module provides WebGL-accelerated rendering capabilities for
//! high-performance interactive dashboards.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use super::widgets::{RenderContext, ShaderProgram, UniformValue, WidgetRender};
use crate::error::{MetricsError, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Rendering engine trait
pub trait RenderingEngine: std::fmt::Debug + Send + Sync {
    /// Initialize rendering engine
    fn initialize(&mut self, config: RenderingConfig) -> Result<()>;

    /// Render widget
    fn render_widget(&self, widget_render: &WidgetRender, context: &RenderContext) -> Result<()>;

    /// Clear render target
    fn clear(&self, color: [f32; 4]) -> Result<()>;

    /// Present rendered frame
    fn present(&self) -> Result<()>;

    /// Get rendering capabilities
    fn capabilities(&self) -> RenderingCapabilities;

    /// Create shader program
    fn create_shader(&self, program: &ShaderProgram) -> Result<String>;

    /// Update uniform values
    fn update_uniforms(
        &self,
        shader_id: &str,
        uniforms: &HashMap<String, UniformValue>,
    ) -> Result<()>;

    /// Set viewport
    fn set_viewport(&self, x: u32, y: u32, width: u32, height: u32) -> Result<()>;
}

/// Rendering configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenderingConfig {
    /// Backend type
    pub backend: RenderingBackend,
    /// Enable anti-aliasing
    pub antialiasing: bool,
    /// Render quality
    pub quality: RenderQuality,
    /// Performance settings
    pub performance: PerformanceSettings,
    /// Buffer configuration
    pub buffers: BufferConfig,
}

/// Rendering backend enumeration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RenderingBackend {
    /// WebGL 2.0
    WebGL2,
    /// WebGL 1.0
    WebGL1,
    /// Canvas 2D
    Canvas2D,
    /// SVG
    SVG,
    /// WebGPU (future)
    WebGPU,
}

/// Render quality enumeration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RenderQuality {
    /// Low quality (performance)
    Low,
    /// Medium quality
    Medium,
    /// High quality
    High,
    /// Ultra quality
    Ultra,
}

/// Performance settings
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceSettings {
    /// Enable frustum culling
    pub frustum_culling: bool,
    /// Enable occlusion culling
    pub occlusion_culling: bool,
    /// Level of detail enabled
    pub lod_enabled: bool,
    /// Instanced rendering
    pub instanced_rendering: bool,
    /// Batch rendering
    pub batch_rendering: bool,
    /// Target FPS
    pub target_fps: u32,
}

/// Buffer configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BufferConfig {
    /// Color buffer format
    pub color_format: ColorFormat,
    /// Depth buffer enabled
    pub depth_buffer: bool,
    /// Stencil buffer enabled
    pub stencil_buffer: bool,
    /// Multisampling level
    pub msaa_samples: u32,
}

/// Color format enumeration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ColorFormat {
    /// RGBA8
    RGBA8,
    /// RGBA16F
    RGBA16F,
    /// RGBA32F
    RGBA32F,
    /// RGB8
    RGB8,
}

/// Rendering capabilities
#[derive(Debug, Clone)]
pub struct RenderingCapabilities {
    /// Maximum texture size
    pub max_texture_size: u32,
    /// Maximum render buffer size
    pub max_render_buffer_size: u32,
    /// Supported extensions
    pub extensions: Vec<String>,
    /// Shader language version
    pub shader_version: String,
    /// WebGL version
    pub webgl_version: f32,
}

/// Update manager for real-time updates
#[derive(Debug)]
pub struct UpdateManager {
    /// Update configuration
    config: UpdateConfig,
    /// Update queue
    update_queue: Vec<UpdateRequest>,
    /// Performance monitor
    performance_monitor: PerformanceMonitor,
}

/// Update configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateConfig {
    /// Update interval
    pub update_interval: std::time::Duration,
    /// Batch size
    pub batch_size: usize,
    /// Enable delta updates
    pub delta_updates: bool,
    /// Prioritization enabled
    pub prioritization: bool,
}

/// Update request
#[derive(Debug, Clone)]
pub struct UpdateRequest {
    /// Widget ID
    pub widget_id: String,
    /// Update type
    pub update_type: UpdateType,
    /// Update data
    pub data: serde_json::Value,
    /// Priority
    pub priority: UpdatePriority,
    /// Timestamp
    pub timestamp: std::time::Instant,
}

/// Update type enumeration
#[derive(Debug, Clone)]
pub enum UpdateType {
    /// Data update
    Data,
    /// Style update
    Style,
    /// Position update
    Position,
    /// Size update
    Size,
    /// Full refresh
    FullRefresh,
}

/// Update priority enumeration
#[derive(Debug, Clone)]
pub enum UpdatePriority {
    /// Low priority
    Low,
    /// Normal priority
    Normal,
    /// High priority
    High,
    /// Critical priority
    Critical,
}

/// Performance monitor
#[derive(Debug)]
pub struct PerformanceMonitor {
    /// Frame times
    frame_times: std::collections::VecDeque<std::time::Duration>,
    /// Render statistics
    stats: RenderStatistics,
    /// Configuration
    config: PerformanceConfig,
}

/// Render statistics
#[derive(Debug, Clone)]
pub struct RenderStatistics {
    /// Average frame time
    pub avg_frame_time: std::time::Duration,
    /// Current FPS
    pub fps: f64,
    /// Draw calls count
    pub draw_calls: u32,
    /// Triangles rendered
    pub triangles: u32,
    /// Memory usage
    pub memory_usage: u64,
}

/// Performance configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceConfig {
    /// Monitoring enabled
    pub enabled: bool,
    /// Sample size for averaging
    pub sample_size: usize,
    /// Performance alerts
    pub alerts_enabled: bool,
    /// Target FPS threshold
    pub fps_threshold: f64,
}

impl UpdateManager {
    /// Create new update manager
    pub fn new(config: UpdateConfig) -> Self {
        Self {
            config,
            update_queue: Vec::new(),
            performance_monitor: PerformanceMonitor::new(),
        }
    }

    /// Queue update request
    pub fn queue_update(&mut self, request: UpdateRequest) {
        self.update_queue.push(request);

        // Sort by priority and timestamp
        self.update_queue.sort_by(|a, b| {
            match (a.priority.priority_value(), b.priority.priority_value()) {
                (a_prio, b_prio) if a_prio != b_prio => b_prio.cmp(&a_prio),
                _ => a.timestamp.cmp(&b.timestamp),
            }
        });
    }

    /// Process update queue
    pub fn process_updates(&mut self) -> Result<Vec<UpdateRequest>> {
        let batch_size = self.config.batch_size.min(self.update_queue.len());
        let updates = self.update_queue.drain(0..batch_size).collect();
        Ok(updates)
    }
}

impl PerformanceMonitor {
    /// Create new performance monitor
    pub fn new() -> Self {
        Self {
            frame_times: std::collections::VecDeque::new(),
            stats: RenderStatistics::default(),
            config: PerformanceConfig::default(),
        }
    }

    /// Record frame time
    pub fn record_frame_time(&mut self, frame_time: std::time::Duration) {
        if self.frame_times.len() >= self.config.sample_size {
            self.frame_times.pop_front();
        }
        self.frame_times.push_back(frame_time);

        self.update_statistics();
    }

    /// Update statistics
    fn update_statistics(&mut self) {
        if self.frame_times.is_empty() {
            return;
        }

        let total_time: std::time::Duration = self.frame_times.iter().sum();
        self.stats.avg_frame_time = total_time / self.frame_times.len() as u32;
        self.stats.fps = 1.0 / self.stats.avg_frame_time.as_secs_f64();
    }

    /// Get current statistics
    pub fn get_statistics(&self) -> &RenderStatistics {
        &self.stats
    }
}

impl UpdatePriority {
    /// Get numeric priority value
    fn priority_value(&self) -> u32 {
        match self {
            UpdatePriority::Low => 1,
            UpdatePriority::Normal => 2,
            UpdatePriority::High => 3,
            UpdatePriority::Critical => 4,
        }
    }
}

impl Default for RenderingConfig {
    fn default() -> Self {
        Self {
            backend: RenderingBackend::WebGL2,
            antialiasing: true,
            quality: RenderQuality::High,
            performance: PerformanceSettings::default(),
            buffers: BufferConfig::default(),
        }
    }
}

impl Default for PerformanceSettings {
    fn default() -> Self {
        Self {
            frustum_culling: true,
            occlusion_culling: false,
            lod_enabled: true,
            instanced_rendering: true,
            batch_rendering: true,
            target_fps: 60,
        }
    }
}

impl Default for BufferConfig {
    fn default() -> Self {
        Self {
            color_format: ColorFormat::RGBA8,
            depth_buffer: true,
            stencil_buffer: false,
            msaa_samples: 4,
        }
    }
}

impl Default for UpdateConfig {
    fn default() -> Self {
        Self {
            update_interval: std::time::Duration::from_millis(16), // ~60 FPS
            batch_size: 50,
            delta_updates: true,
            prioritization: true,
        }
    }
}

impl Default for PerformanceConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            sample_size: 60,
            alerts_enabled: true,
            fps_threshold: 30.0,
        }
    }
}

impl Default for RenderStatistics {
    fn default() -> Self {
        Self {
            avg_frame_time: std::time::Duration::from_millis(16),
            fps: 60.0,
            draw_calls: 0,
            triangles: 0,
            memory_usage: 0,
        }
    }
}