mugltf 0.1.2

Minimal glTF 2.0 asset loader for Rust
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

#![cfg(feature = "fetch-loader")]

use super::GltfResourceLoader;
use alloc::{boxed::Box, string::String, vec::Vec};
use async_trait::async_trait;
use core::fmt;
use js_sys::{Promise, Uint8Array};
use wasm_bindgen::{prelude::*, JsCast};
use wasm_bindgen_futures::JsFuture;
use web_sys::{HtmlImageElement, Request, RequestInit, RequestMode, Response};

/// Loader of glTF resources using [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) API.
#[derive(Debug)]
pub struct GltfResourceFetchLoader {
    path: String,
}

impl Default for GltfResourceFetchLoader {
    fn default() -> Self {
        Self { path: "./".into() }
    }
}

#[async_trait(?Send)]
impl GltfResourceLoader for GltfResourceFetchLoader {
    type Error = FetchLoaderError;
    type ImageData = HtmlImageElement;

    #[inline]
    fn set_path(&mut self, path: &str) {
        self.path = if path.is_empty() {
            "./".into()
        } else if path.chars().last().filter(|end| '/' == *end).is_some() {
            path.into()
        } else {
            [path, "/"].concat()
        };
    }

    async fn get_gltf(&self, uri: &str) -> Result<Vec<u8>, Self::Error> {
        fetch(&[&self.path, uri].concat())
            .await
            .map_err(FetchLoaderError)
    }

    async fn get_buffer(&self, uri: &str) -> Result<Vec<u8>, Self::Error> {
        fetch(&resolve_url(&self.path, uri))
            .await
            .map_err(FetchLoaderError)
    }

    async fn get_image(&self, uri: &str) -> Result<Self::ImageData, Self::Error> {
        load_image(uri).await.map_err(FetchLoaderError)
    }

    async fn decode_image(
        &self,
        img: &[u8],
        mime_type: &str,
    ) -> Result<Self::ImageData, Self::Error> {
        let data_url = ["data:", mime_type, ";base64,", &base64::encode(img)].concat();
        self.get_image(&data_url).await
    }
}

async fn fetch(url: &str) -> Result<Vec<u8>, JsValue> {
    let mut opts = RequestInit::new();
    opts.method("GET");
    opts.mode(RequestMode::Cors);

    let request = Request::new_with_str_and_init(url, &opts)?;

    let window = web_sys::window().ok_or(JsError::new("window is not defined"))?;
    let response: Response = JsFuture::from(window.fetch_with_request(&request))
        .await?
        .dyn_into()?;

    if !response.ok() {
        return Err(response.status().into());
    }

    let content =
        Uint8Array::new_with_byte_offset(&JsFuture::from(response.array_buffer()?).await?, 0)
            .to_vec();

    Ok(content)
}

async fn load_image(uri: &str) -> Result<HtmlImageElement, JsValue> {
    let image = HtmlImageElement::new()?;
    image.set_cross_origin(Some("anonymous"));
    JsFuture::from(Promise::new(&mut |resolve, reject| {
        image.set_onload(Some(&resolve));
        image.set_onerror(Some(&reject));
        image.set_src(uri);
    }))
    .await?;

    Ok(image)
}

fn resolve_url(path: &str, uri: &str) -> String {
    if uri.starts_with("data:") {
        uri.into()
    } else {
        [path, uri].concat()
    }
}

/// Error when calling fetch API
#[derive(Debug)]
pub struct FetchLoaderError(pub JsValue);

impl fmt::Display for FetchLoaderError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "failed to fetch: {}", self.0.as_string().unwrap_or("unknown error".into()))
    }
}

#[cfg(feature = "std")]
impl std::error::Error for FetchLoaderError {}