starlight-renderer 0.0.1

WIP renderer framework
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

use std::sync::Arc;

use vulkano::{
    Validated, VulkanError,
    device::DeviceOwnedVulkanObject,
    image::{
        Image, ImageCreateInfo, ImageLayout, ImageUsage,
        sys::RawImage,
        view::{ImageView, ImageViewCreateInfo},
    },
    memory::{
        DedicatedAllocation, DeviceMemory, MemoryAllocateInfo, MemoryPropertyFlags, ResourceMemory,
    },
    sync::{AccessFlags, ImageMemoryBarrier, PipelineStages},
};

use crate::Context;

pub struct TransientAttachment {
    image: Arc<Image>,
    image_view: Arc<ImageView>,
}
impl TransientAttachment {
    pub fn new(
        ctx: &Context,
        mut create_info: ImageCreateInfo,
        debug_name: &str,
    ) -> Result<Self, Validated<VulkanError>> {
        create_info.usage |= ImageUsage::TRANSIENT_ATTACHMENT;
        create_info.usage |= ImageUsage::INPUT_ATTACHMENT;
        let img = RawImage::new(ctx.device.clone(), create_info)?;
        let mem_reqs = img.memory_requirements();
        let mut raw_mems = Vec::with_capacity(mem_reqs.len());
        let mem_types = ctx
            .phys_dev
            .memory_properties()
            .memory_types
            .iter()
            .enumerate()
            .fold(0u32, |v, (i, mem)| {
                if mem
                    .property_flags
                    .contains(MemoryPropertyFlags::LAZILY_ALLOCATED)
                {
                    v | (1 << i)
                } else {
                    v
                }
            });
        for mem_req in mem_reqs {
            let combined_mem_types = mem_types & mem_req.memory_type_bits;
            let mem_types = (combined_mem_types != 0)
                .then_some(combined_mem_types)
                .unwrap_or(mem_req.memory_type_bits);
            let memory_type_index = (0..32)
                .find(|v| (mem_types & (1 << *v)) != 0)
                .expect("no valid memory type index for transient attachment");

            raw_mems.push(ResourceMemory::new_dedicated(DeviceMemory::allocate(
                ctx.device.clone(),
                MemoryAllocateInfo {
                    allocation_size: mem_req.layout.size(),
                    memory_type_index,
                    dedicated_allocation: (mem_req.requires_dedicated_allocation
                        | mem_req.prefers_dedicated_allocation)
                        .then(|| DedicatedAllocation::Image(&img)),
                    ..Default::default()
                },
            )?));
        }
        let image = match img.bind_memory(raw_mems).map(Arc::new) {
            Ok(v) => v,
            Err((err, _, _)) => return Err(err),
        };
        let image_view = ImageView::new(image.clone(), ImageViewCreateInfo::from_image(&image))?;
        _ = image.set_debug_utils_object_name(Some(debug_name));
        _ = image_view.set_debug_utils_object_name(Some(&format!("{debug_name} View")));
        Ok(Self { image, image_view })
    }
    pub fn image(&self) -> Arc<Image> {
        self.image.clone()
    }
    pub fn image_view(&self) -> Arc<ImageView> {
        self.image_view.clone()
    }
    pub fn image_ref(&self) -> &Arc<Image> {
        &self.image
    }
    pub fn image_view_ref(&self) -> &Arc<ImageView> {
        &self.image_view
    }
    pub fn setup_barrier(
        &self,
        dst_stages: PipelineStages,
        dst_access: AccessFlags,
    ) -> ImageMemoryBarrier {
        ImageMemoryBarrier {
            src_stages: PipelineStages::TOP_OF_PIPE,
            src_access: AccessFlags::empty(),
            dst_stages,
            dst_access,
            // TODO: optimize?
            old_layout: ImageLayout::Undefined,
            // LocalRead would be ideal, but vulkano doesn't have a variant for that
            new_layout: ImageLayout::General,
            subresource_range: self.image.subresource_range(),
            ..ImageMemoryBarrier::image(self.image.clone())
        }
    }
    pub fn local_read_barrier(
        &self,
        src_stages: PipelineStages,
        src_access: AccessFlags,
    ) -> ImageMemoryBarrier {
        ImageMemoryBarrier {
            src_stages,
            src_access,
            // TODO: is there every a case where we can and want to local read outside a fragment
            // shader?
            dst_stages: PipelineStages::FRAGMENT_SHADER,
            dst_access: AccessFlags::INPUT_ATTACHMENT_READ,
            // LocalRead would be ideal, but vulkano doesn't have a variant for that
            old_layout: ImageLayout::General,
            new_layout: ImageLayout::General,
            subresource_range: self.image.subresource_range(),
            ..ImageMemoryBarrier::image(self.image.clone())
        }
    }
}