shdrlib 0.1.5

A three-tiered Vulkan shader compilation and rendering framework built in pure Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! EZ-tier resource wrappers with automatic cleanup
//!
//! Unlike CORE tier resources which require manual `.destroy()` calls,
//! EZ-tier wrappers automatically clean up GPU resources when dropped.

use crate::core::{Buffer as CoreBuffer, Device, Image as CoreImage};
use ash::vk;
use std::sync::Arc;

/// Buffer wrapper with automatic cleanup
///
/// Wraps a CORE `Buffer` and automatically destroys it when dropped.
/// No need to call `.destroy()` manually!
///
/// # Example
///
/// ```rust,no_run
/// use shdrlib::ez::*;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let mut renderer = EzRenderer::new()?;
///
/// // Create a buffer - cleanup is automatic!
/// let buffer = renderer.create_vertex_buffer(&[1.0f32, 2.0, 3.0])?;
///
/// // Use the buffer...
/// // No cleanup needed - Drop handles it!
/// # Ok(())
/// # }
/// ```
pub struct EzBuffer {
    device: Arc<Device>,
    buffer: CoreBuffer,
}

impl EzBuffer {
    /// Create a new EzBuffer (internal use)
    pub(crate) fn new(device: Arc<Device>, buffer: CoreBuffer) -> Self {
        Self { device, buffer }
    }

    /// Get the raw Vulkan buffer handle
    #[inline]
    pub fn handle(&self) -> vk::Buffer {
        self.buffer.handle()
    }

    /// Get the buffer size in bytes
    #[inline]
    pub fn size(&self) -> vk::DeviceSize {
        self.buffer.size()
    }

    /// Get the buffer usage flags
    #[inline]
    pub fn usage(&self) -> vk::BufferUsageFlags {
        self.buffer.usage()
    }

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

impl Drop for EzBuffer {
    fn drop(&mut self) {
        self.buffer.destroy(&self.device);
    }
}

/// Image wrapper with automatic cleanup
///
/// Wraps a CORE `Image` and automatically destroys it when dropped.
/// No need to call `.destroy()` manually!
///
/// # Example
///
/// ```rust,no_run
/// use shdrlib::ez::*;
/// use ash::vk;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// let mut renderer = EzRenderer::new()?;
///
/// // Create a texture - cleanup is automatic!
/// let texture = renderer.create_texture(512, 512, vk::Format::R8G8B8A8_UNORM)?;
///
/// // Use the texture...
/// // No cleanup needed - Drop handles it!
/// # Ok(())
/// # }
/// ```
pub struct EzImage {
    device: Arc<Device>,
    image: CoreImage,
}

impl EzImage {
    /// Create a new EzImage (internal use)
    pub(crate) fn new(device: Arc<Device>, image: CoreImage) -> Self {
        Self { device, image }
    }

    /// Get the raw Vulkan image handle
    #[inline]
    pub fn handle(&self) -> vk::Image {
        self.image.handle()
    }

    /// Get the image view handle
    #[inline]
    pub fn view(&self) -> vk::ImageView {
        self.image.view()
    }

    /// Get the image extent
    #[inline]
    pub fn extent(&self) -> vk::Extent3D {
        self.image.extent()
    }

    /// Get the image format
    #[inline]
    pub fn format(&self) -> vk::Format {
        self.image.format()
    }

    /// Get the image usage flags
    #[inline]
    pub fn usage(&self) -> vk::ImageUsageFlags {
        self.image.usage()
    }

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

impl Drop for EzImage {
    fn drop(&mut self) {
        self.image.destroy(&self.device);
    }
}