lumen-engine 0.2.2

Core composition model and rendering orchestration for Lumen.
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
140
141
142
143
144
145
146
147
148
149

use crate::node::{NodeId, NodeParamEvalContext, NodeParams, PortRef};

use crate::gpu::{
    BoundFrame, CompiledOutput, FrameBindContext, GpuCompileNode, GpuCompiledNode, RasterHandle,
    compiler,
};

pub(crate) const SHADER: &str = include_str!("channel_shuffle.wgsl");

#[derive(
    Debug, Clone, Copy, PartialEq, Eq, Default, lumen_macros::NodeEnum, lumen_macros::Delegate,
)]
#[repr(i64)]
#[delegate(kind = "enum")]
pub enum ChannelSelector {
    #[default]
    Red = 0,
    Green = 1,
    Blue = 2,
    Alpha = 3,
    Zero = 4,
    One = 5,
}

impl ChannelSelector {
    fn as_spec(self) -> &'static str {
        match self {
            Self::Red => "red",
            Self::Green => "green",
            Self::Blue => "blue",
            Self::Alpha => "alpha",
            Self::Zero => "zero",
            Self::One => "one",
        }
    }
}

/// Remaps source raster color channels.
#[derive(Debug, Clone, lumen_macros::Delegate)]
pub struct ChannelShuffleParams {
    /// Source channel mapped into the red output channel.
    #[meta(kind = "enum", enum_type = ChannelSelector)]
    pub red: ChannelSelector,
    /// Source channel mapped into the green output channel.
    #[meta(kind = "enum", enum_type = ChannelSelector)]
    pub green: ChannelSelector,
    /// Source channel mapped into the blue output channel.
    #[meta(kind = "enum", enum_type = ChannelSelector)]
    pub blue: ChannelSelector,
    /// Source channel mapped into the alpha output channel.
    #[meta(kind = "enum", enum_type = ChannelSelector)]
    pub alpha: ChannelSelector,
}

impl Default for ChannelShuffleParams {
    fn default() -> Self {
        Self {
            red: ChannelSelector::Red,
            green: ChannelSelector::Green,
            blue: ChannelSelector::Blue,
            alpha: ChannelSelector::Alpha,
        }
    }
}

/// Remaps source raster color channels.
#[derive(Debug, Clone, lumen_macros::Node)]
#[node(
    kind = "channel_shuffle",
    name = "Channel Shuffle",
    category = "processing"
)]
pub struct ChannelShuffle {
    pub id: NodeId,
    #[params]
    pub params: ChannelShuffleParamsDelegate,

    #[input()]
    pub source: PortRef,
}

impl Default for ChannelShuffle {
    fn default() -> Self {
        Self {
            id: NodeId::new(0),
            params: ChannelShuffleParamsDelegate::default(),
            source: PortRef::empty(),
        }
    }
}

#[derive(Debug, Clone)]
struct CompiledChannelShuffle {
    node_id: NodeId,
    params: ChannelShuffleParamsDelegate,
    buffer: lumen_gpu::BufferId,
}

impl GpuCompiledNode for CompiledChannelShuffle {
    fn node_id(&self) -> NodeId {
        self.node_id
    }

    fn bind(&self, ctx: &FrameBindContext<'_>, bound: &mut BoundFrame) -> crate::Result<()> {
        let params = self.params.eval(&NodeParamEvalContext {
            node_id: self.node_id,
            expr: &ctx.expr_context(self.node_id, "params"),
        })?;
        let selectors = [
            compiler::channel_selector(self.node_id, "red", params.red.as_spec())?,
            compiler::channel_selector(self.node_id, "green", params.green.as_spec())?,
            compiler::channel_selector(self.node_id, "blue", params.blue.as_spec())?,
            compiler::channel_selector(self.node_id, "alpha", params.alpha.as_spec())?,
        ];
        let gpu_params = compiler::ChannelShuffleParams {
            selector_indices: selectors.map(|selector| selector.index),
            selector_values: selectors.map(|selector| selector.value),
        };
        bound.write_buffer(self.buffer, 0, bytemuck::bytes_of(&gpu_params));
        Ok(())
    }
}

impl GpuCompileNode for ChannelShuffle {
    fn compile_gpu(
        &self,
        ctx: &mut crate::gpu::CompileContext<'_>,
        port: &PortRef,
    ) -> crate::Result<CompiledOutput> {
        let (source, texture, params) = ctx.compile_unary_filter(
            self.id,
            &self.source,
            port,
            "channel-shuffle",
            SHADER,
            std::mem::size_of::<compiler::ChannelShuffleParams>() as u64,
        )?;
        ctx.register_compiled_node(CompiledChannelShuffle {
            node_id: self.id,
            params: self.params.clone(),
            buffer: params,
        });
        Ok(CompiledOutput::Raster(RasterHandle {
            texture,
            domain: source.domain,
            metadata: source.metadata,
        }))
    }
}