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

use super::{SceneHostCore, SceneHostError, SceneHostErrorCode};
use crate::{
    AntiAliasing, AssetFetcher, AutoExposureConfig, Background, GridFloorOptions, LookupError,
    PostBloomConfig, ScreenSpaceAmbientOcclusionConfig,
};

impl<F: AssetFetcher> SceneHostCore<F> {
    pub fn apply_product_studio_visuals(&mut self, background: &str) -> Result<(), SceneHostError> {
        let background = scene_host_background(background)?;
        let environment = self.assets.default_environment();
        self.renderer.set_environment(environment);
        self.renderer.set_background(background);
        self.renderer
            .set_auto_exposure(AutoExposureConfig::product_studio());
        self.renderer.set_anti_aliasing(AntiAliasing::Fxaa);
        self.renderer.set_bloom(Some(PostBloomConfig::subtle()));
        self.renderer
            .set_screen_space_ambient_occlusion(Some(ScreenSpaceAmbientOcclusionConfig::subtle()));
        let lights = self.scene.add_studio_lighting()?;
        self.register_node(lights.key);
        self.register_node(lights.fill);
        self.register_node(lights.rim);
        Ok(())
    }

    pub fn add_product_grid_floor_under_node(
        &mut self,
        node: u64,
    ) -> Result<Vec<u64>, SceneHostError> {
        let node = self.resolve_node(node)?;
        let bounds = self
            .scene
            .node_world_bounds(node, &self.assets)?
            .ok_or(LookupError::ImportHasNoBounds)?;
        let floor = self.scene.add_grid_floor(
            &self.assets,
            GridFloorOptions::new()
                .under_bounds(bounds)
                .padding(0.24)
                .line_spacing(0.08),
        )?;
        Ok(vec![
            self.register_node(floor.slab),
            self.register_node(floor.grid),
        ])
    }
}

fn scene_host_background(background: &str) -> Result<Background, SceneHostError> {
    match background {
        "studio_neutral" | "dark_studio" => Ok(Background::DarkStudio),
        "studio" => Ok(Background::Studio),
        "neutral_gray" => Ok(Background::NeutralGray),
        "black" => Ok(Background::Black),
        "white" => Ok(Background::White),
        other => Err(SceneHostError::new(
            SceneHostErrorCode::InvalidInput,
            format!("unsupported SceneHost product studio background {other}"),
        )),
    }
}