goldy 0.2.0

Fondaco Machine GPU runtime for Rust (Vulkan, DX12, Metal)
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

//! Sampler management logic.

use super::types::{self, SamplerState, SharedSamplerTable};
use super::utils::{address_mode_to_vk, compare_to_vk, filter_to_vk, mipmap_mode_to_vk};
use super::{DeviceHandle, SamplerHandle};
use crate::types::SamplerDesc;
use anyhow::{Context, Result};
use ash::vk;
use std::collections::HashMap;

/// Create a sampler with the given description.
pub(super) fn create(
    devices: &HashMap<DeviceHandle, types::SharedLogicalDevice>,
    samplers: &SharedSamplerTable,
    device_handle: DeviceHandle,
    desc: &SamplerDesc,
) -> Result<SamplerHandle> {
    let logical_device = devices.get(&device_handle).context("Invalid device handle")?;

    let sampler_info = vk::SamplerCreateInfo::default()
        .mag_filter(filter_to_vk(desc.mag_filter))
        .min_filter(filter_to_vk(desc.min_filter))
        .mipmap_mode(mipmap_mode_to_vk(desc.mipmap_filter))
        .address_mode_u(address_mode_to_vk(desc.address_mode_u))
        .address_mode_v(address_mode_to_vk(desc.address_mode_v))
        .address_mode_w(address_mode_to_vk(desc.address_mode_w))
        .mip_lod_bias(0.0)
        .anisotropy_enable(desc.max_anisotropy > 1.0)
        .max_anisotropy(desc.max_anisotropy)
        .compare_enable(desc.compare.is_some())
        .compare_op(desc.compare.map(compare_to_vk).unwrap_or(vk::CompareOp::ALWAYS))
        .min_lod(desc.lod_min_clamp)
        .max_lod(desc.lod_max_clamp)
        .border_color(vk::BorderColor::FLOAT_TRANSPARENT_BLACK)
        .unnormalized_coordinates(false);

    let sampler =
        unsafe { logical_device.device.create_sampler(&sampler_info, None) }.context("Failed to create sampler")?;

    let bindless_descriptor_set = logical_device.bindless_descriptor_set;

    let handle = samplers.write().unwrap().alloc_handle();

    let bindless_index = {
        let logical_device = devices.get(&device_handle).unwrap();
        let index = logical_device
            .descriptors
            .lock()
            .unwrap()
            .resource_registry
            .register_sampler(handle);

        // Update the global descriptor set with this sampler
        if let Some(descriptor_set) = bindless_descriptor_set {
            let sampler_info = vk::DescriptorImageInfo::default().sampler(sampler);

            let write = vk::WriteDescriptorSet::default()
                .dst_set(descriptor_set)
                .dst_binding(types::bindless_bindings::SAMPLERS)
                .dst_array_element(index)
                .descriptor_type(vk::DescriptorType::SAMPLER)
                .image_info(std::slice::from_ref(&sampler_info));

            unsafe {
                logical_device
                    .device
                    .update_descriptor_sets(std::slice::from_ref(&write), &[]);
            }

            tracing::trace!("Registered sampler {} at bindless index {}", handle, index);
        }

        Some(index)
    };

    samplers.write().unwrap().entries.insert(
        handle,
        SamplerState {
            device_handle,
            sampler,
            bindless_index,
        },
    );

    tracing::debug!("Created sampler (handle={})", handle);
    Ok(handle)
}

/// Destroy a sampler, unregistering it from bindless and cleaning up GPU resources.
pub(super) fn destroy(
    devices: &HashMap<DeviceHandle, types::SharedLogicalDevice>,
    samplers: &SharedSamplerTable,
    sampler_handle: SamplerHandle,
) {
    if let Some(sampler) = samplers.write().unwrap().entries.remove(&sampler_handle) {
        if let Some(logical_device) = devices.get(&sampler.device_handle) {
            // Defer reclamation: sampler slot must not be reused until all
            // in-flight submissions that referenced it have retired.
            logical_device
                .descriptors
                .lock()
                .unwrap()
                .reclaim_sampler_slots(sampler_handle);

            unsafe {
                let _ = logical_device.synchronized_device_wait_idle();
                logical_device.device.destroy_sampler(sampler.sampler, None);
            }
        }
    }
}

/// Get the bindless descriptor index for a sampler, if any.
pub(super) fn bindless_index(samplers: &SharedSamplerTable, sampler_handle: SamplerHandle) -> Option<u32> {
    samplers
        .read()
        .unwrap()
        .entries
        .get(&sampler_handle)
        .and_then(|s| s.bindless_index)
}