molgfx-render 0.3.2

The render graph, passes and the engine that drives a frame.
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

//! Ordered render-profile resolution kept separate from the public recipe types.

use super::{
    BackdropStyle, BloomStyle, DepthCue, DepthOfField, DisplayTransform, IllustrationStyle,
    LightingEnvironment, MotionBlur, PresentationEffect, RenderProfile, ResolvedRenderPlan,
};

impl RenderProfile {
    pub(crate) fn resolve(&self) -> ResolvedRenderPlan {
        let mut order = (0..self.layers.len()).collect::<Vec<_>>();
        order.sort_by_key(|index| self.layers[*index].priority);
        let mut illustration = IllustrationStyle::default();
        let mut depth_cue = DepthCue::default();
        let mut depth_of_field = None;
        let mut motion_blur = None;
        let mut bloom = None;
        let mut backdrop = BackdropStyle::default();
        let mut lighting = LightingEnvironment::default();
        let mut display = DisplayTransform::default();
        let mut antialias = None;
        for index in order {
            let layer = self.layers[index];
            match layer.effect {
                PresentationEffect::Illustration(style) => {
                    illustration = illustration.blend(style.sanitize(), layer.weight);
                }
                PresentationEffect::DepthCue(cue) => {
                    depth_cue = depth_cue.blend(cue.sanitize(), layer.weight);
                }
                PresentationEffect::DepthOfField(settings) => {
                    let settings = settings.sanitize();
                    let baseline = match depth_of_field {
                        Some(current) => current,
                        None => DepthOfField {
                            max_blur_pixels: 0.0,
                            ..settings
                        },
                    };
                    let resolved = baseline.blend(settings, layer.weight);
                    depth_of_field = (resolved.max_blur_pixels > 0.0).then_some(resolved);
                }
                PresentationEffect::MotionBlur(settings) => {
                    let settings = settings.sanitize();
                    let baseline = match motion_blur {
                        Some(current) => current,
                        None => MotionBlur {
                            shutter: 0.0,
                            max_blur_pixels: 0.0,
                        },
                    };
                    let resolved = baseline.blend(settings, layer.weight);
                    motion_blur = (resolved.shutter > 0.0 && resolved.max_blur_pixels > 0.0)
                        .then_some(resolved);
                }
                PresentationEffect::Backdrop(style) => {
                    backdrop = backdrop.blend(style.sanitize(), layer.weight);
                }
                PresentationEffect::Lighting(environment) => {
                    lighting = lighting.blend(environment.sanitize(), layer.weight);
                }
                PresentationEffect::Display(transform) => {
                    display = display.blend(transform.sanitize(), layer.weight);
                }
                PresentationEffect::AntiAliasing(style) => {
                    antialias = Some(style.sanitize());
                }
                PresentationEffect::Bloom(style) => {
                    let style = style.sanitize();
                    let baseline = match bloom {
                        Some(current) => current,
                        None => BloomStyle {
                            intensity: 0.0,
                            ..style
                        },
                    };
                    let resolved = baseline.blend(style, layer.weight);
                    bloom = (resolved.intensity > 0.0).then_some(resolved);
                }
            }
        }
        ResolvedRenderPlan {
            illustration,
            depth_cue,
            depth_of_field,
            motion_blur,
            bloom,
            backdrop,
            lighting,
            display,
            antialias,
        }
    }
}