favilla 0.3.0

A library with utilities for Vulkan programming.
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

use crate::vk_engine::VulkanEngine;
use ash::{vk, Device};

/// Helper struct holding a command pool and per-frame data: semaphores, fences and command buffers.
pub struct FrameDataManager {
    pub frame_data: Vec<PerFrameData>,
    pub command_pool: vk::CommandPool,
}

impl FrameDataManager {
    /// Creates a new FrameDataManager, including command pool and synchronistation primitives per
    /// in-flight frame.
    /// # Safety
    /// Must be able to create command buffers, fences and semaphores.
    pub unsafe fn new(vk_engine: &VulkanEngine) -> Self {
        let pool_create_info = vk::CommandPoolCreateInfo::builder()
            .flags(
                vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER
                    | vk::CommandPoolCreateFlags::TRANSIENT,
            )
            .queue_family_index(vk_engine.queue_family_index);
        let pool = vk_engine
            .device
            .create_command_pool(&pool_create_info, None)
            .unwrap();

        let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::builder()
            .command_buffer_count(vk_engine.num_frames)
            .command_pool(pool)
            .level(vk::CommandBufferLevel::PRIMARY);

        let command_buffers_per_frame = vk_engine
            .device
            .allocate_command_buffers(&command_buffer_allocate_info)
            .unwrap();

        let semaphore_create_info = vk::SemaphoreCreateInfo::default();

        let mut image_acquired_semaphores = vec![];
        let mut render_complete_semaphores = vec![];
        let mut frame_fences = vec![];

        for _ in 0..vk_engine.num_frames {
            let image_acquired_semaphore = vk_engine
                .device
                .create_semaphore(&semaphore_create_info, None)
                .unwrap();
            image_acquired_semaphores.push(image_acquired_semaphore);
            let render_complete_semaphore = vk_engine
                .device
                .create_semaphore(&semaphore_create_info, None)
                .unwrap();
            render_complete_semaphores.push(render_complete_semaphore);

            let fence_info = vk::FenceCreateInfo {
                flags: vk::FenceCreateFlags::SIGNALED,
                ..Default::default()
            };
            let fence = vk_engine.device.create_fence(&fence_info, None).unwrap();
            frame_fences.push(fence);
        }
        let per_frame_data = (0..vk_engine.num_frames as usize)
            .map(|i| PerFrameData {
                image_acquired_semaphore: image_acquired_semaphores[i],
                render_complete_semaphore: render_complete_semaphores[i],
                frame_fence: frame_fences[i],
                command_buffer: command_buffers_per_frame[i],
            })
            .collect();

        Self {
            frame_data: per_frame_data,
            command_pool: pool,
        }
    }

    /// Frees all resources held by `self`.
    /// # Safety
    /// Resources must not be used anymore.
    pub unsafe fn destroy(&mut self, device: &Device) {
        device.destroy_command_pool(self.command_pool, None);
        for frame_data in &mut self.frame_data {
            frame_data.destroy(device);
        }
    }
}

/// Data held by `FrameDataManager`.
pub struct PerFrameData {
    pub frame_fence: vk::Fence,
    pub command_buffer: vk::CommandBuffer,
    pub image_acquired_semaphore: vk::Semaphore,
    pub render_complete_semaphore: vk::Semaphore,
}

impl PerFrameData {
    /// Frees all resources held by `self`.
    /// # Safety
    /// Resources must not be used anymore.
    pub unsafe fn destroy(&mut self, device: &Device) {
        device.destroy_semaphore(self.image_acquired_semaphore, None);
        device.destroy_semaphore(self.render_complete_semaphore, None);
        device.destroy_fence(self.frame_fence, None);
    }
}