rafx-framework 0.0.16

Rendering framework built on an extensible asset pipeline
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

use crate::resources::descriptor_sets::DescriptorSetBindingKey;
use fnv::FnvHashMap;
use rafx_api::{
    RafxBuffer, RafxBufferDef, RafxDeviceContext, RafxMemoryUsage, RafxQueueType, RafxResourceType,
    RafxResult,
};

//
// Metadata about a buffer for a particular descriptor in a descriptor layout
//
#[derive(Clone)]
pub(super) struct DescriptorSetPoolRequiredBufferInfo {
    pub(super) dst_element: DescriptorSetBindingKey,
    pub(super) descriptor_type: RafxResourceType,
    pub(super) per_descriptor_size: u32,
    pub(super) per_descriptor_stride: u32,
}

//
// Creates and manages the internal buffers for a single binding within a descriptor pool chunk
//
pub(super) struct DescriptorBindingBufferSet {
    pub(super) buffer: RafxBuffer,
    pub(super) buffer_info: DescriptorSetPoolRequiredBufferInfo,
}

impl DescriptorBindingBufferSet {
    fn new(
        device_context: &RafxDeviceContext,
        descriptor_set_count: u32,
        buffer_info: &DescriptorSetPoolRequiredBufferInfo,
    ) -> RafxResult<Self> {
        //This is the only one we support right now
        assert!(buffer_info.descriptor_type == RafxResourceType::UNIFORM_BUFFER);

        let buffer = device_context.create_buffer(&RafxBufferDef {
            size: (buffer_info.per_descriptor_stride * descriptor_set_count) as u64,
            memory_usage: RafxMemoryUsage::CpuToGpu,
            resource_type: RafxResourceType::UNIFORM_BUFFER,
            queue_type: RafxQueueType::Graphics,
            ..Default::default()
        })?;

        Ok(DescriptorBindingBufferSet {
            buffer,
            buffer_info: buffer_info.clone(),
        })
    }
}

//
// Creates and manages the internal buffers for a descriptor pool chunk
//
pub(super) struct DescriptorLayoutBufferSet {
    pub(super) buffer_sets: FnvHashMap<DescriptorSetBindingKey, DescriptorBindingBufferSet>,
}

impl DescriptorLayoutBufferSet {
    pub(super) fn new(
        device_context: &RafxDeviceContext,
        buffer_infos: &[DescriptorSetPoolRequiredBufferInfo],
        descriptor_set_count: u32,
    ) -> RafxResult<Self> {
        let mut buffer_sets: FnvHashMap<DescriptorSetBindingKey, DescriptorBindingBufferSet> =
            Default::default();
        for buffer_info in buffer_infos {
            let buffer = DescriptorBindingBufferSet::new(
                device_context,
                descriptor_set_count,
                &buffer_info,
            )?;
            buffer_sets.insert(buffer_info.dst_element, buffer);
        }

        Ok(DescriptorLayoutBufferSet { buffer_sets })
    }
}