vk-graph 0.14.1+beta

A high-performance Vulkan driver with automatic resource management and execution.
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

mod profile_with_puffin;

use {
    clap::Parser,
    log::error,
    vk_graph::{
        Graph,
        driver::{
            device::{Device, DeviceInfoBuilder},
            surface::Surface,
        },
        pool::hash::HashPool,
    },
    vk_graph_window::swapchain::{Swapchain, SwapchainError, SwapchainInfo},
    winit::{
        application::ApplicationHandler,
        error::EventLoopError,
        event::WindowEvent,
        event_loop::{ActiveEventLoop, EventLoop},
        window::{Window, WindowId},
    },
};

fn main() -> Result<(), EventLoopError> {
    pretty_env_logger::init();
    profile_with_puffin::init();

    EventLoop::new()?.run_app(&mut Application::default())
}

#[derive(Default)]
struct Application(Option<Context>);

impl ApplicationHandler for Application {
    fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
        self.0.as_ref().unwrap().window.request_redraw();
    }

    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window_attributes = Window::default_attributes().with_title("vk-graph");
        let window = event_loop.create_window(window_attributes).unwrap();

        let args = Args::parse();
        let device_info = DeviceInfoBuilder::default().debug(args.debug);
        let device = Device::try_from_display(&window, device_info).unwrap();

        let surface = Surface::create(&device, &window, &window).unwrap();
        let surface_formats = Surface::formats(&surface).unwrap();
        let surface_format = Surface::linear_or_default(&surface_formats);
        let window_size = window.inner_size();
        let present_mode = Surface::present_modes(&surface)
            .unwrap()
            .first()
            .copied()
            .unwrap();
        let swapchain = Swapchain::new(
            surface,
            SwapchainInfo::new(window_size.width, window_size.height, surface_format)
                .into_builder()
                .present_mode(present_mode),
        )
        .unwrap();

        let swapchain_pool = HashPool::new(&device);

        self.0 = Some(Context {
            swapchain,
            swapchain_pool,
            window,
        });
    }

    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        _window_id: WindowId,
        event: WindowEvent,
    ) {
        let context = self.0.as_mut().unwrap();

        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::Resized(size) => {
                let mut swapchain_info = context.swapchain.info;
                swapchain_info.width = size.width;
                swapchain_info.height = size.height;
                context.swapchain.set_info(swapchain_info);
            }
            WindowEvent::RedrawRequested => {
                if let Err(err) = context.draw() {
                    // This would be a good time to recreate the device or surface
                    error!("unable to draw window: {err}");

                    event_loop.exit();
                };

                profiling::finish_frame!();
            }
            _ => (),
        }
    }
}

#[derive(Parser)]
struct Args {
    /// Enable Vulkan SDK validation layers
    #[arg(long)]
    debug: bool,
}

struct Context {
    swapchain: Swapchain,
    swapchain_pool: HashPool,
    window: Window,
}

impl Context {
    fn draw(&mut self) -> Result<(), SwapchainError> {
        if let Some(swapchain_image) = self.swapchain.acquire_next_image()? {
            let mut graph = Graph::default();
            let swapchain_image = graph.bind_resource(swapchain_image);

            // Rendering goes here!
            graph.clear_color_image(swapchain_image, [1.0, 0.0, 1.0, 1.0]);

            self.window.pre_present_notify();
            self.swapchain
                .present_image(&mut self.swapchain_pool, graph, swapchain_image, 0)?;
        }

        Ok(())
    }
}