motion-core 0.2.0

Backend-independent motion engine primitives
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

//! Immutable evaluation environment shared by scene and drawing contexts.

use std::sync::Arc;

use super::RenderQuality;

/// Time, quality and explicit resources for one evaluation.
///
/// `SceneContext` and `DrawContext` build on the same environment so deferred
/// content sees identical time, quality, assets, fonts, diagnostics and compute
/// caches whichever one measures or records it. The environment is immutable
/// once shared; builders take `self` and drawing contexts hold it by [`Arc`].
#[derive(Clone, Debug)]
pub struct Evaluation {
    time: crate::Time,
    quality: RenderQuality,
    assets: crate::Assets,
    fonts: Option<crate::asset::environment::FontEnvironment>,
    diagnostics: crate::RequestDiagnostics,
    cache: Option<crate::RenderCache>,
}

impl Default for Evaluation {
    fn default() -> Self {
        Self {
            time: crate::Time::ZERO,
            quality: RenderQuality::Final,
            assets: crate::Assets::default(),
            fonts: None,
            diagnostics: crate::RequestDiagnostics::default(),
            cache: None,
        }
    }
}

impl Evaluation {
    /// Creates a Final-quality environment at time zero without assets or caches.
    pub fn new() -> Self {
        Self::default()
    }

    /// Selects an explicit approximation policy for deferred content.
    pub fn with_quality(mut self, quality: RenderQuality) -> Self {
        self.quality = quality;
        self
    }

    /// Production quality is the default.
    pub fn quality(&self) -> RenderQuality {
        self.quality
    }

    /// Supplies scene-local signed time to deferred content effects.
    pub fn with_time(mut self, time: crate::Time) -> Self {
        self.time = time;
        self
    }

    /// Scene-local time; defaults to zero.
    pub fn time(&self) -> crate::Time {
        self.time
    }

    /// Captures the same lazy/preloaded owner used by the enclosing session.
    ///
    /// The assets inherit this environment's diagnostics, and their font
    /// environment replaces any previously supplied one.
    pub fn with_assets(mut self, assets: &crate::Assets) -> Self {
        self.assets = assets.clone().with_diagnostics(self.diagnostics.clone());
        if let Some(fonts) = assets.fonts() {
            self.fonts = Some(fonts.clone());
        }
        self
    }

    /// Explicit resource owner; an unconfigured environment resolves no relative files.
    pub fn assets(&self) -> &crate::Assets {
        &self.assets
    }

    /// Supplies a shared explicit font snapshot.
    pub fn with_fonts(
        mut self,
        fonts: impl Into<crate::asset::environment::FontEnvironment>,
    ) -> Self {
        self.fonts = Some(fonts.into());
        self
    }

    /// Font environment for paragraph text, optional for geometry-only content.
    pub fn fonts(&self) -> Option<&crate::asset::environment::FontEnvironment> {
        self.fonts.as_ref()
    }

    /// Carries request diagnostics explicitly through deferred content compilation.
    pub fn with_diagnostics(mut self, diagnostics: crate::RequestDiagnostics) -> Self {
        self.diagnostics = diagnostics;
        self.assets = self.assets.with_diagnostics(self.diagnostics.clone());
        self
    }

    /// Request-owned sink; cloning the environment preserves its identity.
    pub fn diagnostics(&self) -> &crate::RequestDiagnostics {
        &self.diagnostics
    }

    /// Supplies partitioned compute caches shared by rendering workers.
    pub fn with_cache(mut self, cache: crate::RenderCache) -> Self {
        self.cache = Some(cache);
        self
    }

    /// Shared compute-cache partitions, absent for standalone uncached evaluation.
    pub fn cache(&self) -> Option<&crate::RenderCache> {
        self.cache.as_ref()
    }

    /// Shares this environment between contexts without copying it.
    pub fn shared(self) -> Arc<Self> {
        Arc::new(self)
    }
}