glitcher_core/

debug.rs

//! Debug Information Types
//!
//! Types for exposing internal engine state to UI inspectors.
//! These are designed for debugging and visualization, not for runtime use.

/// Debug information for a parameter
#[derive(Debug, Clone)]
pub struct ParamDebugInfo {
    /// Parameter name
    pub name: String,
    /// Parameter type (f32, vec2, vec4, etc.)
    pub param_type: String,
    /// Widget type (slider, button, button_group, etc.)
    pub widget: String,
    /// Current value as string
    pub current_value: String,
    /// Byte offset in param buffer
    pub offset: u64,
    /// Size in bytes
    pub size: u64,
}

/// Debug information for a port
#[derive(Debug, Clone)]
pub struct PortDebugInfo {
    /// Port name
    pub name: String,
    /// Port direction (input/output)
    pub direction: String,
    /// Port type (texture, storage, etc.)
    pub port_type: String,
    /// Binding slot
    pub binding: u32,
    /// Format (for storage textures)
    pub format: Option<String>,
    /// Whether the port is connected
    pub is_connected: bool,
}

/// Debug information for an action
#[derive(Debug, Clone)]
pub struct ActionDebugInfo {
    /// Action ID
    pub id: String,
    /// Display label
    pub label: String,
    /// Action type (Trigger, BeatSync, etc.)
    pub action_type: String,
}

/// Debug information for a node in the graph
#[derive(Debug, Clone)]
pub struct NodeDebugInfo {
    /// Node ID (as string for display)
    pub id: String,
    /// Definition ID (plugin name)
    pub def_id: String,
    /// Display name
    pub name: String,
    /// Node kind (Shader/TextureSource)
    pub kind: String,
    /// Input connections: (input_index, source_node_id)
    pub inputs: Vec<(usize, String)>,
    /// Output texture info (if applicable)
    pub output_texture: Option<TextureDebugInfo>,
    /// Buffer offset in parameter buffer
    pub buffer_offset: Option<u64>,
    /// Buffer size in parameter buffer
    pub buffer_size: Option<u64>,
    /// Actions available for this node
    pub actions: Vec<ActionDebugInfo>,
    /// Parameters defined for this node
    pub params: Vec<ParamDebugInfo>,
    /// Ports defined for this node
    pub ports: Vec<PortDebugInfo>,
}

/// Debug information for a texture
#[derive(Debug, Clone)]
pub struct TextureDebugInfo {
    /// Texture name (for external textures) or index (for intermediates)
    pub name: String,
    /// Width in pixels
    pub width: u32,
    /// Height in pixels
    pub height: u32,
    /// Texture format as string
    pub format: String,
    /// Whether this is an external texture
    pub is_external: bool,
}

/// Complete graph debug information
#[derive(Debug, Clone, Default)]
pub struct GraphDebugInfo {
    /// All nodes in the graph
    pub nodes: Vec<NodeDebugInfo>,
    /// External textures registered in the engine
    pub external_textures: Vec<TextureDebugInfo>,
    /// Intermediate textures created during compilation
    pub intermediate_textures: Vec<TextureDebugInfo>,
    /// Whether the graph is compiled
    pub is_compiled: bool,
    /// Total parameter buffer size
    pub param_buffer_size: Option<u64>,
    /// Number of execution steps
    pub execution_steps: usize,
}

impl GraphDebugInfo {
    /// Create empty debug info
    pub fn empty() -> Self {
        Self::default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_node_debug_info_creation() {
        let info = NodeDebugInfo {
            id: "node_1".to_string(),
            def_id: "solid-color".to_string(),
            name: "Solid Color".to_string(),
            kind: "Shader(Fragment)".to_string(),
            inputs: vec![(0, "node_0".to_string())],
            output_texture: None,
            buffer_offset: Some(0),
            buffer_size: Some(16),
            actions: vec![ActionDebugInfo {
                id: "flash".to_string(),
                label: "Flash".to_string(),
                action_type: "BeatSync".to_string(),
            }],
            params: vec![ParamDebugInfo {
                name: "intensity".to_string(),
                param_type: "f32".to_string(),
                widget: "slider".to_string(),
                current_value: "0.5".to_string(),
                offset: 0,
                size: 4,
            }],
            ports: vec![PortDebugInfo {
                name: "output".to_string(),
                direction: "output".to_string(),
                port_type: "texture".to_string(),
                binding: 0,
                format: None,
                is_connected: true,
            }],
        };

        assert_eq!(info.id, "node_1");
        assert_eq!(info.def_id, "solid-color");
        assert_eq!(info.inputs.len(), 1);
        assert_eq!(info.buffer_offset, Some(0));
        assert_eq!(info.actions.len(), 1);
        assert_eq!(info.actions[0].id, "flash");
        assert_eq!(info.params.len(), 1);
        assert_eq!(info.params[0].name, "intensity");
        assert_eq!(info.ports.len(), 1);
    }

    #[test]
    fn test_texture_debug_info_creation() {
        let info = TextureDebugInfo {
            name: "intermediate_0".to_string(),
            width: 1920,
            height: 1080,
            format: "Rgba8Unorm".to_string(),
            is_external: false,
        };

        assert_eq!(info.width, 1920);
        assert_eq!(info.height, 1080);
        assert!(!info.is_external);
    }

    #[test]
    fn test_graph_debug_info_empty() {
        let info = GraphDebugInfo::empty();

        assert!(info.nodes.is_empty());
        assert!(info.external_textures.is_empty());
        assert!(info.intermediate_textures.is_empty());
        assert!(!info.is_compiled);
        assert_eq!(info.param_buffer_size, None);
        assert_eq!(info.execution_steps, 0);
    }

    #[test]
    fn test_graph_debug_info_with_nodes() {
        let mut info = GraphDebugInfo::empty();

        info.nodes.push(NodeDebugInfo {
            id: "1v1".to_string(),
            def_id: "empty".to_string(),
            name: "Empty".to_string(),
            kind: "Shader(Fragment)".to_string(),
            inputs: vec![],
            output_texture: Some(TextureDebugInfo {
                name: "intermediate_0".to_string(),
                width: 1920,
                height: 1080,
                format: "Rgba8Unorm".to_string(),
                is_external: false,
            }),
            buffer_offset: None,
            buffer_size: None,
            actions: vec![],
            params: vec![],
            ports: vec![],
        });

        info.is_compiled = true;
        info.execution_steps = 2;

        assert_eq!(info.nodes.len(), 1);
        assert!(info.is_compiled);
        assert_eq!(info.execution_steps, 2);
        assert!(info.nodes[0].output_texture.is_some());
    }

    #[test]
    fn test_debug_info_clone() {
        let info = NodeDebugInfo {
            id: "test".to_string(),
            def_id: "test-def".to_string(),
            name: "Test".to_string(),
            kind: "Shader".to_string(),
            inputs: vec![(0, "other".to_string())],
            output_texture: None,
            buffer_offset: Some(256),
            buffer_size: Some(32),
            actions: vec![],
            params: vec![],
            ports: vec![],
        };

        let cloned = info.clone();
        assert_eq!(info.id, cloned.id);
        assert_eq!(info.buffer_offset, cloned.buffer_offset);
    }
}