scena 1.7.1

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

use wasm_bindgen::prelude::*;

use super::animation::{SceneHostAnimationLoopMode, SceneHostAnimationPlayOptions};
use super::wasm::{SceneHost, js_error};
use super::{SceneHostError, SceneHostErrorCode};

#[wasm_bindgen]
impl SceneHost {
    #[wasm_bindgen(js_name = animationInventoryJson)]
    pub fn animation_inventory_json(&self, import: u64) -> Result<String, JsValue> {
        self.core.animation_inventory_json(import).map_err(js_error)
    }

    #[wasm_bindgen(js_name = playAnimation)]
    pub fn play_animation(
        &mut self,
        import: u64,
        clip_name: String,
        options: JsValue,
    ) -> Result<u64, JsValue> {
        self.core
            .play_animation(
                import,
                &clip_name,
                play_options_from_js(options).map_err(js_error)?,
            )
            .map_err(js_error)
    }

    #[wasm_bindgen(js_name = pauseAnimation)]
    pub fn pause_animation(&mut self, handle: u64) -> Result<(), JsValue> {
        self.core.pause_animation(handle).map_err(js_error)
    }

    #[wasm_bindgen(js_name = stopAnimation)]
    pub fn stop_animation(&mut self, handle: u64) -> Result<(), JsValue> {
        self.core.stop_animation(handle).map_err(js_error)
    }

    #[wasm_bindgen(js_name = seekAnimation)]
    pub fn seek_animation(&mut self, handle: u64, seconds: f64) -> Result<(), JsValue> {
        self.core.seek_animation(handle, seconds).map_err(js_error)
    }

    #[wasm_bindgen(js_name = setAnimationSpeed)]
    pub fn set_animation_speed(&mut self, handle: u64, speed: f64) -> Result<(), JsValue> {
        self.core
            .set_animation_speed(handle, speed)
            .map_err(js_error)
    }

    pub fn advance(&mut self, delta_seconds: f64) -> Result<(), JsValue> {
        self.core.advance(delta_seconds).map_err(js_error)
    }
}

fn play_options_from_js(options: JsValue) -> Result<SceneHostAnimationPlayOptions, SceneHostError> {
    if options.is_null() || options.is_undefined() {
        return Ok(SceneHostAnimationPlayOptions::default());
    }
    if !options.is_object() {
        return Err(invalid_options("playAnimation options must be an object"));
    }

    let loop_mode = js_property_string(&options, "loop_mode")?
        .or(js_property_string(&options, "loopMode")?)
        .map(|value| match value.as_str() {
            "once" => Ok(SceneHostAnimationLoopMode::Once),
            "repeat" => Ok(SceneHostAnimationLoopMode::Repeat),
            other => Err(invalid_options(format!(
                "unsupported playAnimation loop_mode {other}"
            ))),
        })
        .transpose()?
        .unwrap_or_default();
    let speed = js_property_number(&options, "speed")?.unwrap_or(1.0) as f32;

    Ok(SceneHostAnimationPlayOptions { loop_mode, speed })
}

fn js_property_string(object: &JsValue, name: &str) -> Result<Option<String>, SceneHostError> {
    let value = js_sys::Reflect::get(object, &JsValue::from_str(name))
        .map_err(|_| invalid_options(format!("could not read option {name}")))?;
    if value.is_null() || value.is_undefined() {
        return Ok(None);
    }
    value
        .as_string()
        .map(Some)
        .ok_or_else(|| invalid_options(format!("option {name} must be a string")))
}

fn js_property_number(object: &JsValue, name: &str) -> Result<Option<f64>, SceneHostError> {
    let value = js_sys::Reflect::get(object, &JsValue::from_str(name))
        .map_err(|_| invalid_options(format!("could not read option {name}")))?;
    if value.is_null() || value.is_undefined() {
        return Ok(None);
    }
    value
        .as_f64()
        .map(Some)
        .ok_or_else(|| invalid_options(format!("option {name} must be a number")))
}

fn invalid_options(message: impl Into<String>) -> SceneHostError {
    SceneHostError::new(SceneHostErrorCode::InvalidInput, message.into())
}