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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Surface module - Window surface wrapper
//!
//! **WARNING**: CORE objects do NOT enforce lifetime dependencies.
//! Surfaces must not outlive the instance.

use crate::core::Instance;
use ash::khr::surface;
use ash::vk;
use thiserror::Error;

/// Surface operation error
#[derive(Debug, Error)]
pub enum SurfaceError {
    #[error("Surface creation failed: {0}")]
    CreationFailed(vk::Result),

    #[error("Surface query failed: {0}")]
    QueryFailed(vk::Result),

    #[error("No suitable surface formats found")]
    NoSurfaceFormats,

    #[error("No suitable present modes found")]
    NoPresentModes,
}

/// Surface wrapper
///
/// Represents a platform-specific window surface for rendering.
///
/// # Safety
///
/// This object does NOT enforce that the instance outlives it.
/// Using a surface after dropping the instance causes undefined behavior.
pub struct Surface {
    surface: vk::SurfaceKHR,
    surface_loader: surface::Instance,
}

impl Surface {
    /// Create a surface from a raw Vulkan surface handle
    pub fn from_raw(instance: &Instance, surface: vk::SurfaceKHR) -> Self {
        let surface_loader = surface::Instance::new(instance.entry(), instance.handle());
        Self {
            surface,
            surface_loader,
        }
    }

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

    /// Get the surface loader
    #[inline]
    pub fn loader(&self) -> &surface::Instance {
        &self.surface_loader
    }

    /// Query surface capabilities for a physical device
    pub fn get_capabilities(
        &self,
        physical_device: vk::PhysicalDevice,
    ) -> Result<vk::SurfaceCapabilitiesKHR, SurfaceError> {
        unsafe {
            self.surface_loader
                .get_physical_device_surface_capabilities(physical_device, self.surface)
                .map_err(SurfaceError::QueryFailed)
        }
    }

    /// Query supported surface formats for a physical device
    pub fn get_formats(
        &self,
        physical_device: vk::PhysicalDevice,
    ) -> Result<Vec<vk::SurfaceFormatKHR>, SurfaceError> {
        let formats = unsafe {
            self.surface_loader
                .get_physical_device_surface_formats(physical_device, self.surface)
                .map_err(SurfaceError::QueryFailed)?
        };

        if formats.is_empty() {
            return Err(SurfaceError::NoSurfaceFormats);
        }

        Ok(formats)
    }

    /// Query supported present modes for a physical device
    pub fn get_present_modes(
        &self,
        physical_device: vk::PhysicalDevice,
    ) -> Result<Vec<vk::PresentModeKHR>, SurfaceError> {
        let present_modes = unsafe {
            self.surface_loader
                .get_physical_device_surface_present_modes(physical_device, self.surface)
                .map_err(SurfaceError::QueryFailed)?
        };

        if present_modes.is_empty() {
            return Err(SurfaceError::NoPresentModes);
        }

        Ok(present_modes)
    }

    /// Check if a queue family supports presentation to this surface
    pub fn get_physical_device_surface_support(
        &self,
        physical_device: vk::PhysicalDevice,
        queue_family_index: u32,
    ) -> Result<bool, SurfaceError> {
        unsafe {
            self.surface_loader
                .get_physical_device_surface_support(
                    physical_device,
                    queue_family_index,
                    self.surface,
                )
                .map_err(SurfaceError::QueryFailed)
        }
    }

    /// Destroy the surface manually
    pub fn destroy(&mut self) {
        unsafe {
            self.surface_loader.destroy_surface(self.surface, None);
        }
        self.surface = vk::SurfaceKHR::null();
    }
}

impl Drop for Surface {
    fn drop(&mut self) {
        if self.surface != vk::SurfaceKHR::null() {
            eprintln!("WARNING: Surface dropped without manual destroy() - potential leak");
        }
    }
}

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

    #[test]
    fn test_surface_from_raw() {
        let instance = Instance::new(InstanceCreateInfo {
            enable_validation: false,
            ..Default::default()
        })
        .unwrap();

        let raw_surface = vk::SurfaceKHR::null();
        let surface = Surface::from_raw(&instance, raw_surface);

        assert_eq!(surface.handle(), vk::SurfaceKHR::null());
    }
}