ambient_renderer 0.2.1

Ambient renderer. Host-only.
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

use std::sync::Arc;

use ambient_app::{App, AppBuilder};
use ambient_core::{asset_cache, camera::active_camera, hierarchy::set_component_recursive, main_scene, mesh, transform::*};
use ambient_ecs::Entity;
use ambient_gpu::{
    gpu::GpuKey,
    shader_module::{BindGroupDesc, ShaderModule},
};
use ambient_meshes::QuadMeshKey;
use ambient_model_import::model_crate::ModelCrate;
use ambient_renderer::{
    gpu_primitives_lod, gpu_primitives_mesh, material,
    materials::flat_material::{get_flat_shader, FlatMaterial},
    primitives, renderer_shader, Material, MaterialShader, SharedMaterial, StandardShaderKey, MATERIAL_BIND_GROUP,
};
use ambient_std::{
    asset_cache::{AssetCache, SyncAssetKey, SyncAssetKeyExt},
    asset_url::AbsAssetUrl,
    cb, friendly_id,
    math::SphericalCoords,
};
use glam::*;
use wgpu::BindGroup;

fn get_custom_material_layout() -> BindGroupDesc<'static> {
    BindGroupDesc { entries: vec![], label: MATERIAL_BIND_GROUP.into() }
}

#[derive(Clone, Debug)]
pub struct CustomMaterialShaderKey;
impl SyncAssetKey<Arc<MaterialShader>> for CustomMaterialShaderKey {
    fn load(&self, _assets: AssetCache) -> Arc<MaterialShader> {
        Arc::new(MaterialShader {
            id: "custom_material_shader".to_string(),
            shader: Arc::new(
                ShaderModule::new("CustomMaterial", include_str!("material.wgsl")).with_binding_desc(get_custom_material_layout()),
            ),
        })
    }
}

pub struct CustomMaterial {
    id: String,
    bind_group: wgpu::BindGroup,
}
impl CustomMaterial {
    pub fn new(assets: AssetCache) -> Self {
        let gpu = GpuKey.get(&assets);
        let layout = get_custom_material_layout().get(&assets);

        Self {
            id: friendly_id(),
            bind_group: gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {
                layout: &layout,
                entries: &[],
                label: Some("CustomMaterial.bind_group"),
            }),
        }
    }
}
impl std::fmt::Debug for CustomMaterial {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("CustomMaterial").field("id", &self.id).finish()
    }
}
impl Material for CustomMaterial {
    fn bind_group(&self) -> &BindGroup {
        &self.bind_group
    }
    fn id(&self) -> &str {
        &self.id
    }
}

async fn init(app: &mut App) {
    let world = &mut app.world;
    let assets = world.resource(asset_cache()).clone();

    let model = ModelCrate::local_import(&assets, &AbsAssetUrl::parse("assets/Soldier.glb").unwrap(), true, false).await.unwrap();
    let entity = model.spawn(world, &Default::default());
    set_component_recursive(
        world,
        entity,
        renderer_shader(),
        cb(|assets, config| {
            StandardShaderKey { material_shader: CustomMaterialShaderKey.get(assets), lit: true, shadow_cascades: config.shadow_cascades }
                .get(assets)
        }),
    );
    set_component_recursive(world, entity, material(), SharedMaterial::new(CustomMaterial::new(assets.clone())));
    // world.add_component(entity, rotation(), glam::Quat::from_rotation_x(std::f32::consts::PI / 2.)).unwrap();
    // world.set(entity, animation_controller(), AnimationController::looping("Walk")).unwrap();

    let grey = FlatMaterial::new(assets.clone(), vec4(0.5, 0.5, 0.5, 1.), Some(false));

    Entity::new()
        .with(mesh(), QuadMeshKey.get(&assets))
        .with(renderer_shader(), cb(get_flat_shader))
        .with(material(), SharedMaterial::new(grey))
        .with(primitives(), vec![])
        .with_default(gpu_primitives_mesh())
        .with_default(gpu_primitives_lod())
        .with_default(local_to_world())
        .with_default(mesh_to_world())
        .with(scale(), vec3(20., 20., 1.))
        .with(main_scene(), ())
        .spawn(world);

    ambient_cameras::spherical::new(vec3(0., 0., 0.), SphericalCoords::new(std::f32::consts::PI / 4., std::f32::consts::PI / 4., 5.))
        .with(active_camera(), 0.)
        .with(main_scene(), ())
        .spawn(world);
}

fn main() {
    env_logger::init();
    AppBuilder::simple().block_on(init);
}