shdrlib 0.1.2

//! EzRenderer - The all-in-one rendering interface
//!
//! Single struct that manages the entire Vulkan rendering stack with sensible defaults.
//! Perfect for teaching, prototyping, and quick iteration.
//!
//! ## Example - Hello Triangle in 30 lines!
//!
//! ```rust,no_run
//! use shdrlib::ez::*;
//!
//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
//! // One-liner setup
//! let mut renderer = EzRenderer::new()?;
//!
//! // Compile shaders and build pipeline in one call
//! let pipeline_id = renderer.quick_pipeline(VERTEX_GLSL, FRAGMENT_GLSL)?;
//!
//! // Render frames
//! for _ in 0..60 {
//!     renderer.render_frame(|frame| {
//!         frame.bind_pipeline(pipeline_id);
//!         frame.draw(3, 1, 0, 0); // Draw 3 vertices
//!         Ok(())
//!     })?;
//! }
//! # Ok(())
//! # }
//! # const VERTEX_GLSL: &str = "#version 450\nvoid main() {}";
//! # const FRAGMENT_GLSL: &str = "#version 450\nvoid main() {}";
//! ```

use crate::core::ShaderStage;
use crate::ex::{
    PipelineBuilder, PipelineId, RuntimeConfig, RuntimeManager, ShaderId, ShaderManager,
};
use crate::ez::errors::EzError;
use ash::vk;
use std::sync::Arc;

/// Configuration for EzRenderer with sensible defaults
#[derive(Clone)]
pub struct EzConfig {
    /// Application name (shown in Vulkan tools)
    pub app_name: String,

    /// Enable validation layers (auto-enabled in debug builds)
    pub enable_validation: bool,

    /// Number of in-flight frames (double buffering by default)
    pub in_flight_frames: usize,
}

impl Default for EzConfig {
    fn default() -> Self {
        Self {
            app_name: "EZ Renderer".to_string(),
            enable_validation: cfg!(debug_assertions),
            in_flight_frames: 2,
        }
    }
}

/// Frame rendering context with simplified API
pub struct EzFrame<'a> {
    device: Arc<crate::core::Device>,
    command_buffer: vk::CommandBuffer,
    shader_manager: &'a ShaderManager,
}

impl<'a> EzFrame<'a> {
    /// Bind a pipeline for rendering
    #[inline]
    pub fn bind_pipeline(&self, pipeline_id: PipelineId) -> Result<(), EzError> {
        let pipeline = self.shader_manager.get_pipeline(pipeline_id)?;

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_bind_pipeline(
                self.command_buffer,
                vk::PipelineBindPoint::GRAPHICS,
                pipeline.handle(),
            );
        }
        Ok(())
    }

    /// Bind a compute pipeline
    #[inline]
    pub fn bind_compute_pipeline(&self, pipeline_id: PipelineId) -> Result<(), EzError> {
        let pipeline = self.shader_manager.get_pipeline(pipeline_id)?;

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_bind_pipeline(
                self.command_buffer,
                vk::PipelineBindPoint::COMPUTE,
                pipeline.handle(),
            );
        }
        Ok(())
    }

    /// Set viewport dynamically
    #[inline]
    pub fn set_viewport(&self, x: f32, y: f32, width: f32, height: f32) {
        let viewport = vk::Viewport {
            x,
            y,
            width,
            height,
            min_depth: 0.0,
            max_depth: 1.0,
        };

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device
                .handle()
                .cmd_set_viewport(self.command_buffer, 0, &[viewport]);
        }
    }

    /// Set scissor rectangle
    #[inline]
    pub fn set_scissor(&self, x: i32, y: i32, width: u32, height: u32) {
        let scissor = vk::Rect2D {
            offset: vk::Offset2D { x, y },
            extent: vk::Extent2D { width, height },
        };

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device
                .handle()
                .cmd_set_scissor(self.command_buffer, 0, &[scissor]);
        }
    }

    /// Draw command
    #[inline]
    pub fn draw(
        &self,
        vertex_count: u32,
        instance_count: u32,
        first_vertex: u32,
        first_instance: u32,
    ) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_draw(
                self.command_buffer,
                vertex_count,
                instance_count,
                first_vertex,
                first_instance,
            );
        }
    }

    /// Draw indexed command
    #[inline]
    pub fn draw_indexed(
        &self,
        index_count: u32,
        instance_count: u32,
        first_index: u32,
        vertex_offset: i32,
        first_instance: u32,
    ) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_draw_indexed(
                self.command_buffer,
                index_count,
                instance_count,
                first_index,
                vertex_offset,
                first_instance,
            );
        }
    }

    /// Bind vertex buffers
    #[inline]
    pub fn bind_vertex_buffers(
        &self,
        first_binding: u32,
        buffers: &[vk::Buffer],
        offsets: &[vk::DeviceSize],
    ) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_bind_vertex_buffers(
                self.command_buffer,
                first_binding,
                buffers,
                offsets,
            );
        }
    }

    /// Bind index buffer
    #[inline]
    pub fn bind_index_buffer(
        &self,
        buffer: vk::Buffer,
        offset: vk::DeviceSize,
        index_type: vk::IndexType,
    ) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_bind_index_buffer(
                self.command_buffer,
                buffer,
                offset,
                index_type,
            );
        }
    }

    /// Dispatch compute shader
    #[inline]
    pub fn dispatch(&self, group_count_x: u32, group_count_y: u32, group_count_z: u32) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_dispatch(
                self.command_buffer,
                group_count_x,
                group_count_y,
                group_count_z,
            );
        }
    }

    /// Bind descriptor sets
    #[inline]
    pub fn bind_descriptor_sets(
        &self,
        pipeline_bind_point: vk::PipelineBindPoint,
        layout: vk::PipelineLayout,
        first_set: u32,
        descriptor_sets: &[vk::DescriptorSet],
    ) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_bind_descriptor_sets(
                self.command_buffer,
                pipeline_bind_point,
                layout,
                first_set,
                descriptor_sets,
                &[],
            );
        }
    }

    /// Push constants
    #[inline]
    pub fn push_constants<T: Copy>(
        &self,
        layout: vk::PipelineLayout,
        stage_flags: vk::ShaderStageFlags,
        offset: u32,
        constants: &T,
    ) {
        let size = std::mem::size_of::<T>() as u32;
        let data = unsafe {
            std::slice::from_raw_parts(constants as *const T as *const u8, size as usize)
        };

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_push_constants(
                self.command_buffer,
                layout,
                stage_flags,
                offset,
                data,
            );
        }
    }

    /// Begin rendering with dynamic rendering (Vulkan 1.3+)
    #[inline]
    pub fn begin_rendering(&self, width: u32, height: u32, _format: vk::Format) {
        let color_attachment = vk::RenderingAttachmentInfo {
            image_view: vk::ImageView::null(), // User provides actual image view
            image_layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
            load_op: vk::AttachmentLoadOp::CLEAR,
            store_op: vk::AttachmentStoreOp::STORE,
            clear_value: vk::ClearValue {
                color: vk::ClearColorValue {
                    float32: [0.0, 0.0, 0.0, 1.0],
                },
            },
            ..Default::default()
        };

        let rendering_info = vk::RenderingInfo {
            render_area: vk::Rect2D {
                offset: vk::Offset2D { x: 0, y: 0 },
                extent: vk::Extent2D { width, height },
            },
            layer_count: 1,
            color_attachment_count: 1,
            p_color_attachments: &color_attachment,
            ..Default::default()
        };

        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device
                .handle()
                .cmd_begin_rendering(self.command_buffer, &rendering_info);
        }
    }

    /// End rendering pass
    #[inline]
    pub fn end_rendering(&self) {
        // SAFETY: device and command buffer handles are valid
        unsafe {
            self.device.handle().cmd_end_rendering(self.command_buffer);
        }
    }

    /// Get raw command buffer handle (for advanced usage)
    #[inline]
    pub fn command_buffer(&self) -> vk::CommandBuffer {
        self.command_buffer
    }

    /// Get device reference (for advanced usage)
    #[inline]
    pub fn device(&self) -> &Arc<crate::core::Device> {
        &self.device
    }
}

/// EzRenderer - All-in-one rendering interface
///
/// Wraps RuntimeManager and ShaderManager into a single, easy-to-use API.
/// Perfect for learning, prototyping, and quick rendering tasks.
///
/// # Features
///
/// - One-liner initialization
/// - Automatic resource management
/// - Sensible defaults everywhere
/// - Simple frame API
/// - Helper methods for common tasks
///
/// # Example
///
/// ```rust,no_run
/// use shdrlib::ez::*;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let mut renderer = EzRenderer::new()?;
/// let pipeline = renderer.quick_pipeline(VERT_SRC, FRAG_SRC)?;
///
/// renderer.render_frame(|frame| {
///     frame.bind_pipeline(pipeline);
///     frame.draw(3, 1, 0, 0);
///     Ok(())
/// })?;
/// # Ok(())
/// # }
/// # const VERT_SRC: &str = "#version 450\nvoid main() {}";
/// # const FRAG_SRC: &str = "#version 450\nvoid main() {}";
/// ```
pub struct EzRenderer {
    // IMPORTANT: Drop order matters!
    // Rust drops fields in declaration order (top to bottom)
    // shader_manager must drop BEFORE runtime (contains Device Arc)
    shader_manager: ShaderManager,
    runtime: RuntimeManager,
}

impl EzRenderer {
    /// Create a new EzRenderer with default configuration
    ///
    /// # Errors
    ///
    /// Returns error if Vulkan initialization fails.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use shdrlib::ez::*;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let renderer = EzRenderer::new()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new() -> Result<Self, EzError> {
        Self::with_config(EzConfig::default())
    }

    /// Create a new EzRenderer with custom configuration
    ///
    /// # Errors
    ///
    /// Returns error if Vulkan initialization fails.
    pub fn with_config(config: EzConfig) -> Result<Self, EzError> {
        let runtime = RuntimeManager::new(RuntimeConfig {
            app_name: config.app_name,
            enable_validation: config.enable_validation,
            in_flight_frames: config.in_flight_frames,
            ..Default::default()
        })
        .map_err(|e| EzError::InitializationFailed(e.to_string()))?;

        let device = runtime.device();
        let shader_manager =
            ShaderManager::new(device).map_err(|e| EzError::InitializationFailed(e.to_string()))?;

        Ok(Self {
            runtime,
            shader_manager,
        })
    }

    /// Compile vertex and fragment shaders and create a graphics pipeline in one call
    ///
    /// This is the quickest way to get a rendering pipeline up and running.
    /// Uses sensible defaults for all pipeline state.
    ///
    /// # Arguments
    ///
    /// * `vertex_glsl` - GLSL vertex shader source
    /// * `fragment_glsl` - GLSL fragment shader source
    ///
    /// # Returns
    ///
    /// Returns a `PipelineId` that can be used with `bind_pipeline()`.
    ///
    /// # Errors
    ///
    /// Returns error if shader compilation or pipeline creation fails.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use shdrlib::ez::*;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut renderer = EzRenderer::new()?;
    ///
    /// let pipeline = renderer.quick_pipeline(
    ///     r#"#version 450
    ///     void main() {
    ///         gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
    ///     }"#,
    ///     r#"#version 450
    ///     layout(location = 0) out vec4 color;
    ///     void main() {
    ///         color = vec4(1.0, 0.0, 0.0, 1.0);
    ///     }"#
    /// )?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn quick_pipeline(
        &mut self,
        vertex_glsl: &str,
        fragment_glsl: &str,
    ) -> Result<PipelineId, EzError> {
        // Compile shaders
        let vert_id = self.add_shader(vertex_glsl, ShaderStage::Vertex)?;
        let frag_id = self.add_shader(fragment_glsl, ShaderStage::Fragment)?;

        // Build pipeline with sensible defaults
        let pipeline_id = self.shader_manager.build_pipeline(
            PipelineBuilder::new()
                .vertex_shader(self.shader_manager.get_shader(vert_id)?.handle(), "main")
                .fragment_shader(self.shader_manager.get_shader(frag_id)?.handle(), "main")
                .color_attachment_formats(vec![vk::Format::R8G8B8A8_UNORM])
                .dynamic_viewport()
                .dynamic_scissor(),
            "ez_pipeline",
        )?;

        Ok(pipeline_id)
    }

    /// Compile a compute shader and create a compute pipeline in one call
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use shdrlib::ez::*;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut renderer = EzRenderer::new()?;
    ///
    /// let compute = renderer.quick_compute(
    ///     r#"#version 450
    ///     layout(local_size_x = 16, local_size_y = 16) in;
    ///     void main() {
    ///         // Compute work
    ///     }"#
    /// )?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn quick_compute(&mut self, compute_glsl: &str) -> Result<PipelineId, EzError> {
        let comp_id = self.add_shader(compute_glsl, ShaderStage::Compute)?;

        let pipeline_id = self.shader_manager.build_pipeline(
            PipelineBuilder::new()
                .compute_shader(self.shader_manager.get_shader(comp_id)?.handle(), "main"),
            "ez_compute",
        )?;

        Ok(pipeline_id)
    }

    /// Compile a single shader from GLSL source
    ///
    /// # Errors
    ///
    /// Returns error if shader compilation fails.
    pub fn add_shader(&mut self, glsl: &str, stage: ShaderStage) -> Result<ShaderId, EzError> {
        let name = format!("ez_shader_{}", self.shader_manager.shader_count());
        self.shader_manager
            .add_shader(glsl, stage, &name)
            .map_err(|e| EzError::ShaderCompilationFailed(e.to_string()))
    }

    /// Build a custom pipeline using PipelineBuilder
    ///
    /// For more control than `quick_pipeline()` provides.
    ///
    /// # Errors
    ///
    /// Returns error if pipeline creation fails.
    pub fn build_pipeline(&mut self, builder: PipelineBuilder) -> Result<PipelineId, EzError> {
        let name = format!("ez_pipeline_{}", self.shader_manager.pipeline_count());
        self.shader_manager
            .build_pipeline(builder, &name)
            .map_err(|e| EzError::PipelineCreationFailed(e.to_string()))
    }

    /// Render a single frame with a user-provided closure
    ///
    /// Handles all frame synchronization and command buffer lifecycle.
    ///
    /// # Errors
    ///
    /// Returns error if frame rendering fails.
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// use shdrlib::ez::*;
    ///
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// # let pipeline = renderer.quick_pipeline("", "")?;
    /// renderer.render_frame(|frame| {
    ///     frame.bind_pipeline(pipeline)?;
    ///     frame.set_viewport(0.0, 0.0, 800.0, 600.0);
    ///     frame.set_scissor(0, 0, 800, 600);
    ///     frame.draw(3, 1, 0, 0);
    ///     Ok(())
    /// })?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn render_frame<F>(&mut self, f: F) -> Result<(), EzError>
    where
        F: FnOnce(&EzFrame) -> Result<(), EzError>,
    {
        // Begin frame
        let frame = self
            .runtime
            .begin_frame()
            .map_err(|e| EzError::FrameFailed(e.to_string()))?;

        // Begin command buffer recording
        frame
            .command_buffer
            .begin(&frame.device, vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT)
            .map_err(|e| EzError::FrameFailed(e.to_string()))?;

        // Execute user's rendering commands
        let ez_frame = EzFrame {
            device: frame.device.clone(),
            command_buffer: frame.command_buffer.handle(),
            shader_manager: &self.shader_manager,
        };
        f(&ez_frame)?;

        // End command buffer recording
        frame
            .command_buffer
            .end(&frame.device)
            .map_err(|e| EzError::FrameFailed(e.to_string()))?;

        // Submit frame
        self.runtime
            .end_frame(&Default::default())
            .map_err(|e| EzError::FrameFailed(e.to_string()))?;

        Ok(())
    }

    /// Get a reference to the underlying RuntimeManager (for advanced usage)
    #[inline]
    pub fn runtime(&self) -> &RuntimeManager {
        &self.runtime
    }

    /// Get a mutable reference to the underlying RuntimeManager (for advanced usage)
    #[inline]
    pub fn runtime_mut(&mut self) -> &mut RuntimeManager {
        &mut self.runtime
    }

    /// Get a reference to the underlying ShaderManager (for advanced usage)
    #[inline]
    pub fn shader_manager(&self) -> &ShaderManager {
        &self.shader_manager
    }

    /// Get a mutable reference to the underlying ShaderManager (for advanced usage)
    #[inline]
    pub fn shader_manager_mut(&mut self) -> &mut ShaderManager {
        &mut self.shader_manager
    }

    /// Wait for all GPU operations to complete
    ///
    /// Useful before cleanup or when synchronization is needed.
    pub fn wait_idle(&self) -> Result<(), EzError> {
        self.runtime
            .wait_idle()
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Get number of compiled shaders
    #[inline]
    pub fn shader_count(&self) -> usize {
        self.shader_manager.shader_count()
    }

    /// Get number of created pipelines
    #[inline]
    pub fn pipeline_count(&self) -> usize {
        self.shader_manager.pipeline_count()
    }

    // ========== Buffer Helpers ==========

    /// Create a vertex buffer with data
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let vertices: Vec<f32> = vec![0.0, -0.5, 0.5, 0.5, -0.5, 0.5];
    /// let vertex_buffer = renderer.create_vertex_buffer(&vertices)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_vertex_buffer<T: Copy>(
        &self,
        data: &[T],
    ) -> Result<crate::core::Buffer, EzError> {
        crate::ex::helpers::create_vertex_buffer(&self.runtime.device(), data)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create an index buffer with data
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let indices: Vec<u16> = vec![0, 1, 2];
    /// let index_buffer = renderer.create_index_buffer(&indices)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_index_buffer<T: Copy>(&self, data: &[T]) -> Result<crate::core::Buffer, EzError> {
        crate::ex::helpers::create_index_buffer(&self.runtime.device(), data)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create a uniform buffer for type T
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// #[repr(C)]
    /// struct CameraData {
    ///     view_proj: [[f32; 4]; 4],
    /// }
    /// let uniform_buffer = renderer.create_uniform_buffer::<CameraData>()?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_uniform_buffer<T>(&self) -> Result<crate::core::Buffer, EzError> {
        crate::ex::helpers::create_uniform_buffer::<T>(&self.runtime.device())
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create a storage buffer (GPU read/write)
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let storage_buffer = renderer.create_storage_buffer(1024 * 1024)?; // 1MB
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_storage_buffer(&self, size: u64) -> Result<crate::core::Buffer, EzError> {
        crate::ex::helpers::create_storage_buffer(&self.runtime.device(), size)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Write data to a host-visible buffer
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// # let uniform_buffer = renderer.create_uniform_buffer::<f32>()?;
    /// let data: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0];
    /// renderer.write_buffer(&uniform_buffer, &data)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn write_buffer<T: Copy>(
        &self,
        buffer: &crate::core::Buffer,
        data: &[T],
    ) -> Result<(), EzError> {
        crate::ex::helpers::write_buffer(&self.runtime.device(), buffer, data)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    // ========== Image/Texture Helpers ==========

    /// Create a render target (color attachment)
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let render_target = renderer.create_render_target(800, 600, ash::vk::Format::R8G8B8A8_UNORM)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_render_target(
        &self,
        width: u32,
        height: u32,
        format: vk::Format,
    ) -> Result<crate::core::Image, EzError> {
        crate::ex::helpers::create_render_target(&self.runtime.device(), width, height, format)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create a depth/stencil attachment
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let depth_buffer = renderer.create_depth_stencil(800, 600, ash::vk::Format::D32_SFLOAT)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_depth_stencil(
        &self,
        width: u32,
        height: u32,
        format: vk::Format,
    ) -> Result<crate::core::Image, EzError> {
        crate::ex::helpers::create_depth_stencil(&self.runtime.device(), width, height, format)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create a texture for sampling in shaders
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let texture = renderer.create_texture(256, 256, ash::vk::Format::R8G8B8A8_UNORM)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_texture(
        &self,
        width: u32,
        height: u32,
        format: vk::Format,
    ) -> Result<crate::core::Image, EzError> {
        crate::ex::helpers::create_texture(&self.runtime.device(), width, height, format)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }

    /// Create a storage image for compute shaders
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use shdrlib::ez::*;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let mut renderer = EzRenderer::new()?;
    /// let storage_image = renderer.create_storage_image(512, 512, ash::vk::Format::R8G8B8A8_UNORM)?;
    /// # Ok(())
    /// # }
    /// ```
    #[inline]
    pub fn create_storage_image(
        &self,
        width: u32,
        height: u32,
        format: vk::Format,
    ) -> Result<crate::core::Image, EzError> {
        crate::ex::helpers::create_storage_image(&self.runtime.device(), width, height, format)
            .map_err(|e| EzError::RuntimeError(e.to_string()))
    }
}

// Automatic cleanup through RuntimeManager and ShaderManager Drop implementations
impl Drop for EzRenderer {
    fn drop(&mut self) {
        // Wait for device idle before cleanup
        let _ = self.wait_idle();
    }
}

impl std::fmt::Debug for EzRenderer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EzRenderer")
            .field("shaders", &self.shader_manager.shader_count())
            .field("pipelines", &self.shader_manager.pipeline_count())
            .finish()
    }
}