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::BTreeSet;

use serde_json::Value;

use crate::scene::recipe::types::SceneRecipeDiagnosticV1;
use crate::scene::recipe::validation::diagnostic;

use super::super::finite_vec3;

pub(in crate::scene::recipe::validation::authoring) fn validate_look_at_target(
    path: &str,
    value: Option<&Value>,
    node_ids: &BTreeSet<String>,
    import_ids: &BTreeSet<String>,
    diagnostics: &mut Vec<SceneRecipeDiagnosticV1>,
) {
    match value {
        Some(Value::String(target))
            if is_declared_node_or_import_path(target, node_ids, import_ids) => {}
        Some(Value::String(target)) if is_import_path_ref(target) => {
            diagnostics.push(unknown_import_path_diagnostic(path, target));
        }
        Some(Value::String(target)) => diagnostics.push(diagnostic(
            "unknown_node_ref",
            "error",
            path,
            format!("look_at target references unknown node '{target}'"),
            "target an authored node id, imported node path, or provide a [x,y,z] position",
            None,
            false,
        )),
        Some(value) if finite_vec3(value).is_some() => {}
        Some(_) => diagnostics.push(diagnostic(
            "invalid_look_at_target",
            "error",
            path,
            "look_at target must be an authored node id, imported node path, or finite [x,y,z] position",
            "target an authored node id, imported node path such as part:/Node, or provide a [x,y,z] position",
            None,
            false,
        )),
        None => diagnostics.push(diagnostic(
            "missing_look_at_target",
            "error",
            path,
            "look_at transform requires a target",
            "target an authored node id, imported node path, or provide a [x,y,z] position",
            None,
            false,
        )),
    }
}

pub(in crate::scene::recipe::validation::authoring) fn validate_node_ref(
    path: &str,
    value: Option<&Value>,
    node_ids: &BTreeSet<String>,
    import_ids: &BTreeSet<String>,
    diagnostics: &mut Vec<SceneRecipeDiagnosticV1>,
) {
    match value.and_then(Value::as_str) {
        Some(value) if is_declared_node_or_import_path(value, node_ids, import_ids) => {}
        Some(value) if is_import_path_ref(value) => {
            diagnostics.push(unknown_import_path_diagnostic(path, value));
        }
        Some(value) => diagnostics.push(diagnostic(
            "unknown_node_ref",
            "error",
            path,
            format!("node reference '{value}' does not name a declared authored node or imported node path"),
            "declare a node with this id or target an imported node path such as part:/Node",
            None,
            false,
        )),
        None => diagnostics.push(diagnostic(
            "missing_node_ref",
            "error",
            path,
            "node reference must be a string",
            "set node to an authored node id or imported node path such as part:/Node",
            None,
            false,
        )),
    }
}

fn is_declared_node_or_import_path(
    value: &str,
    node_ids: &BTreeSet<String>,
    import_ids: &BTreeSet<String>,
) -> bool {
    node_ids.contains(value)
        || import_path_import(value).is_some_and(|import| import_ids.contains(import))
}

fn is_import_path_ref(value: &str) -> bool {
    import_path_import(value).is_some()
}

fn import_path_import(value: &str) -> Option<&str> {
    let (import, _path) = value.split_once(":/")?;
    (!import.trim().is_empty()).then_some(import)
}

fn unknown_import_path_diagnostic(path: &str, value: &str) -> SceneRecipeDiagnosticV1 {
    let import = import_path_import(value).unwrap_or(value);
    diagnostic(
        "unknown_import_ref",
        "error",
        path,
        format!("imported node path '{value}' references unknown import '{import}'"),
        "declare the import id before targeting imported node paths",
        None,
        false,
    )
}