bevy_solari 0.20.0

Provides raytraced lighting for Bevy Engine
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

mod binder;
mod blas;
mod extract;
mod types;

use bevy_asset::embedded_asset;
use bevy_shader::load_shader_library;
pub use binder::prepare_raytracing_scene_resources;
pub use binder::{RaytracingSceneBindings, RaytracingSceneNeedsPreviousFrameData};
pub use types::RaytracingMesh3d;

use crate::SolariPlugins;
use bevy_app::{App, Plugin};
use bevy_ecs::schedule::IntoScheduleConfigs;
use bevy_render::{
    mesh::{
        allocator::{allocate_and_free_meshes, MeshAllocatorSettings},
        RenderMesh,
    },
    render_asset::prepare_assets,
    render_resource::{update_sparse_buffers, BufferUsages},
    renderer::{RenderDevice, RenderGraph, RenderGraphSystems},
    ExtractSchedule, GpuResourceAppExt, Render, RenderApp, RenderSystems,
};
use binder::{
    build_raytracing_tlas, prepare_raytracing_scene_bind_group, TlasInstanceSetupPipeline,
};
use blas::{compact_raytracing_blas, delete_raytracing_blas, prepare_raytracing_blas, BlasManager};
use extract::{
    extract_raytracing_environment_map_light, extract_raytracing_material_assets,
    extract_raytracing_scene_meshes_and_materials, extract_raytracing_scene_structural,
    extract_raytracing_scene_transforms, ExtractedEnvironmentMapLight, StandardMaterialAssets,
};
use tracing::warn;

/// Creates acceleration structures and binding arrays of resources for raytracing.
pub struct RaytracingScenePlugin;

impl Plugin for RaytracingScenePlugin {
    fn build(&self, app: &mut App) {
        load_shader_library!(app, "brdf.wesl");
        load_shader_library!(app, "bindings.wesl");
        load_shader_library!(app, "sampling.wesl");
        embedded_asset!(app, "binder/setup_tlas_instances.wesl");
    }

    fn finish(&self, app: &mut App) {
        let render_app = app.sub_app_mut(RenderApp);

        let render_device = render_app.world().resource::<RenderDevice>();
        let features = render_device.features();
        if !features.contains(SolariPlugins::required_wgpu_features()) {
            warn!(
                "RaytracingScenePlugin not loaded. GPU lacks support for required features: {:?}.",
                SolariPlugins::required_wgpu_features().difference(features)
            );
            return;
        }

        render_app
            .world_mut()
            .resource_mut::<MeshAllocatorSettings>()
            .extra_buffer_usages |= BufferUsages::BLAS_INPUT | BufferUsages::STORAGE;

        render_app
            .init_resource::<ExtractedEnvironmentMapLight>()
            .init_gpu_resource::<BlasManager>()
            .init_gpu_resource::<StandardMaterialAssets>()
            .init_gpu_resource::<RaytracingSceneBindings>()
            .init_gpu_resource::<TlasInstanceSetupPipeline>()
            .add_systems(
                ExtractSchedule,
                (
                    extract_raytracing_scene_structural,
                    extract_raytracing_scene_transforms,
                    extract_raytracing_scene_meshes_and_materials,
                    extract_raytracing_material_assets,
                    extract_raytracing_environment_map_light,
                ),
            )
            .add_systems(
                Render,
                (
                    prepare_raytracing_blas
                        .in_set(RenderSystems::PrepareAssets)
                        .before(prepare_assets::<RenderMesh>)
                        .after(allocate_and_free_meshes),
                    compact_raytracing_blas
                        .in_set(RenderSystems::PrepareAssets)
                        .after(prepare_raytracing_blas),
                    prepare_raytracing_scene_resources.in_set(RenderSystems::PrepareResources),
                    prepare_raytracing_scene_bind_group.in_set(RenderSystems::PrepareBindGroups),
                ),
            )
            .add_systems(
                RenderGraph,
                (
                    build_raytracing_tlas
                        .after(update_sparse_buffers)
                        .in_set(RenderGraphSystems::Begin),
                    delete_raytracing_blas.in_set(RenderGraphSystems::Finish),
                ),
            );
    }
}