scena 1.7.2

A Rust-native scene-graph renderer with typed scene state, glTF assets, and explicit prepare/render lifecycles.
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

use std::collections::BTreeMap;
use std::fs;

use crate::scene::recipe::{
    RecipeBuildPolicy, SceneRecipeBuildResourceV1, SceneRecipeBuildSkippedV1,
    SceneRecipeDiagnosticV1, SceneRecipeFontV1, build_diagnostic,
};
use crate::{LabelFontError, LabelFontFace};

use super::super::error_diagnostic;

pub(in crate::scene_host::recipe) fn build_authored_fonts(
    policy: &RecipeBuildPolicy,
    recipe_path: &str,
    recipes: &[SceneRecipeFontV1],
    manifest: &mut Vec<SceneRecipeBuildResourceV1>,
    skipped: &mut Vec<SceneRecipeBuildSkippedV1>,
    diagnostics: &mut Vec<SceneRecipeDiagnosticV1>,
) -> BTreeMap<String, LabelFontFace> {
    let mut fonts = BTreeMap::new();
    for (index, recipe) in recipes.iter().enumerate() {
        let path = format!("$.fonts[{index}]");
        let resolved =
            match policy.resolve_import_uri(recipe_path, &recipe.uri, format!("{path}.uri")) {
                Ok(uri) => uri,
                Err(diagnostic) => {
                    diagnostics.push(*diagnostic);
                    continue;
                }
            };
        let bytes = match fs::read(&resolved) {
            Ok(bytes) => bytes,
            Err(error) if recipe.optional => {
                diagnostics.push(build_diagnostic(
                    "optional_font_skipped",
                    "warning",
                    &path,
                    format!("optional font '{}' could not be loaded: {error}", recipe.id),
                    "the font was marked optional, so the build continues without it",
                    None,
                    false,
                ));
                skipped.push(SceneRecipeBuildSkippedV1 {
                    path,
                    id: recipe.id.clone(),
                    kind: "font".to_owned(),
                    reason: error.to_string(),
                });
                continue;
            }
            Err(error) => {
                diagnostics.push(error_diagnostic(
                    &path,
                    "font_load_failed",
                    format!("required font '{}' could not be loaded: {error}", recipe.id),
                    "fix the font uri or mark it optional only when no label references it",
                ));
                continue;
            }
        };
        if bytes.len() > policy.fetch_byte_limit() {
            diagnostics.push(error_diagnostic(
                format!("{path}.uri"),
                "policy_violation",
                format!(
                    "font fetched {} bytes, exceeding RecipeBuildPolicy fetch_byte_limit {}",
                    bytes.len(),
                    policy.fetch_byte_limit()
                ),
                "use a smaller font or raise the operator-owned fetch_byte_limit policy",
            ));
            continue;
        }
        let font = match LabelFontFace::from_truetype_bytes(&bytes) {
            Ok(font) => font,
            Err(LabelFontError::InvalidFont { reason }) if recipe.optional => {
                diagnostics.push(build_diagnostic(
                    "optional_font_skipped",
                    "warning",
                    &path,
                    format!(
                        "optional font '{}' could not be parsed: {reason}",
                        recipe.id
                    ),
                    "the font was marked optional, so the build continues without it",
                    None,
                    false,
                ));
                skipped.push(SceneRecipeBuildSkippedV1 {
                    path,
                    id: recipe.id.clone(),
                    kind: "font".to_owned(),
                    reason,
                });
                continue;
            }
            Err(error) => {
                diagnostics.push(error_diagnostic(
                    &path,
                    "font_load_failed",
                    format!("required font '{}' could not be parsed: {error}", recipe.id),
                    "use a valid TrueType/OpenType font file",
                ));
                continue;
            }
        };
        fonts.insert(recipe.id.clone(), font);
        manifest.push(SceneRecipeBuildResourceV1 {
            id: recipe.id.clone(),
            kind: "truetype_font".to_owned(),
            vertex_count: None,
            index_count: None,
        });
    }
    fonts
}