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
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
130
131
132
133
134
135
136
137
138
139

use crate::render_features::render_features_prelude::*;
use crate::render_features::RenderFeatureFlag;

/// The `SubmitNodeBlock` is a collection of `SubmitNode` associated with a particular `RenderFeature`,
/// `RenderView`, and `RenderPhase`. There should be a 1:1 mapping between `SubmitNode`s and draw calls
/// from the `RenderFeature`'s `WriteJob`. The `Renderer` will combine all `SubmitNodeBlock`s sharing the
/// same `RenderView` and `RenderPhase` into a sorted `ViewPhaseSubmitNodeBlock`.
pub struct SubmitNodeBlock<SubmitPacketDataT: SubmitPacketData> {
    feature_index: RenderFeatureIndex,
    render_phase: RenderPhaseIndex,
    submit_nodes: AtomicOnceCellStack<SubmitNode<SubmitPacketDataT::SubmitNodeData>>,
}

impl<SubmitPacketDataT: 'static + Sync + Send + SubmitPacketData>
    SubmitNodeBlock<SubmitPacketDataT>
{
    pub fn len(&self) -> usize {
        self.submit_nodes.len()
    }

    /// Creates a `SubmitNodeBlock` with a capacity of `num_submit_nodes` if the `RenderView`
    /// supports the `RenderPhase`, otherwise the capacity will be set to `0`.
    pub fn with_capacity<RenderPhaseT: RenderPhase>(
        view: &RenderView,
        num_submit_nodes: usize,
    ) -> Self {
        Self {
            feature_index: SubmitPacketDataT::RenderFeature::feature_index(),
            render_phase: RenderPhaseT::render_phase_index(),
            submit_nodes: AtomicOnceCellStack::with_capacity(
                if view.phase_is_relevant::<RenderPhaseT>() {
                    num_submit_nodes
                } else {
                    0
                },
            ),
        }
    }

    /// Creates a `SubmitNodeBlock` with a capacity of `num_submit_nodes` if the `RenderView`
    /// supports the `RenderPhase` and `RenderFeatureFlag`, otherwise the capacity will be set to `0`.
    pub fn with_capacity_and_feature_flag<
        RenderPhaseT: RenderPhase,
        RenderFeatureFlagT: RenderFeatureFlag,
    >(
        view: &RenderView,
        num_submit_nodes: usize,
    ) -> Self {
        Self {
            feature_index: SubmitPacketDataT::RenderFeature::feature_index(),
            render_phase: RenderPhaseT::render_phase_index(),
            submit_nodes: AtomicOnceCellStack::with_capacity(
                if view.phase_is_relevant::<RenderPhaseT>()
                    && view.feature_flag_is_relevant::<RenderFeatureFlagT>()
                {
                    num_submit_nodes
                } else {
                    0
                },
            ),
        }
    }

    pub fn push_submit_node(
        &self,
        data: SubmitPacketDataT::SubmitNodeData,
        sort_key: SubmitNodeSortKey,
        distance: f32,
    ) -> SubmitNodeId {
        self.submit_nodes.push(SubmitNode {
            sort_key,
            distance,
            data,
        }) as SubmitNodeId
    }

    pub fn get_submit_node_data(
        &self,
        index: SubmitNodeId,
    ) -> &SubmitNode<SubmitPacketDataT::SubmitNodeData> {
        self.submit_nodes.get(index as usize)
    }

    pub fn is_relevant(
        &self,
        render_phase: RenderPhaseIndex,
    ) -> bool {
        self.render_phase == render_phase
    }
}

impl<SubmitPacketDataT: 'static + Sync + Send + SubmitPacketData> RenderFeatureSubmitNodeBlock
    for SubmitNodeBlock<SubmitPacketDataT>
{
    fn render_phase(&self) -> RenderPhaseIndex {
        self.render_phase
    }

    fn num_submit_nodes(&self) -> usize {
        self.len()
    }

    fn get_submit_node(
        &self,
        submit_node_id: SubmitNodeId,
    ) -> RenderFeatureSubmitNode {
        let submit_node = self.get_submit_node_data(submit_node_id);
        RenderFeatureSubmitNode::new(
            self.feature_index,
            submit_node_id,
            submit_node.sort_key,
            submit_node.distance,
        )
    }

    fn feature_index(&self) -> RenderFeatureIndex {
        self.feature_index
    }
}

/// Each `SubmitNode` contains the data needed for the `RenderFeature`'s `RenderFeatureWriteJob` to
/// render a draw call by referencing data in the frame packet, submit packet, render objects set, or
/// some other storage. `SubmitNode`s will be sorted by the `RenderPhase` after they are combined into
/// a `ViewPhaseSubmitNodeBlock`.
pub struct SubmitNode<T> {
    pub sort_key: SubmitNodeSortKey,
    pub distance: f32,
    pub data: T,
}

impl<T: Default> SubmitNode<T> {
    pub fn new() -> Self {
        Self {
            sort_key: 0,
            distance: 0.,
            data: T::default(),
        }
    }
}