crystal-vk 0.1.1

Graphics wrapper for Vulkan
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

pub mod framebuffer;
mod render_pass;
pub mod surface;
pub mod swapchain;

use std::{
    error::Error,
    sync::{Arc, RwLock},
};

use ash::vk;

use crate::{
    device::Device,
    image::{Image, ImageType},
    render::{
        framebuffer::FramebufferPool,
        render_pass::{RenderPass, RenderPassInfo},
    },
    traits::CommandBufferBinding,
};

pub struct RenderTarget {
    pub(crate) framebuffer: Arc<RwLock<FramebufferPool>>,
    pub device: Arc<Device>,
}

unsafe impl Send for RenderTarget {}
unsafe impl Sync for RenderTarget {}

impl CommandBufferBinding for RenderTarget {}

impl RenderTarget {
    pub fn new(
        device: Arc<Device>,
        image_sequence: Vec<Arc<Image>>,
        msaa_samples: u8,
    ) -> Result<Arc<Self>, Box<dyn Error>> {
        let counts = device
            .physical_device
            .info
            .properties
            .limits
            .framebuffer_color_sample_counts
            & device
                .physical_device
                .info
                .properties
                .limits
                .framebuffer_depth_sample_counts;

        let samples = match msaa_samples {
            2 => vk::SampleCountFlags::TYPE_2,
            4 => vk::SampleCountFlags::TYPE_4,
            8 => vk::SampleCountFlags::TYPE_8,
            16 => vk::SampleCountFlags::TYPE_16,
            32 => vk::SampleCountFlags::TYPE_32,
            64 => vk::SampleCountFlags::TYPE_64,
            _ => vk::SampleCountFlags::TYPE_1,
        };

        if !samples.intersects(counts) {
            return Err(
                format!("device is not supported for sample count: {}", msaa_samples).into(),
            );
        };

        let present = image_sequence[0].info.typ == ImageType::Swapchain;

        let render_pass = RenderPass::new(
            device.clone(),
            RenderPassInfo {
                samples,
                format: image_sequence[0].info.format,
                present,
            },
        )?;

        let framebuffer = FramebufferPool::new(render_pass.clone(), image_sequence)?;

        Ok(Arc::new(Self {
            framebuffer,
            device,
        }))
    }
}