bevy-aabb-instancing 0.11.0

Render millions of AABB instances in Bevy.
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
122
123
124
125

use super::buffers::*;
use super::cuboid_cache::CuboidBufferCache;
use super::draw::{AuxiliaryMeta, TransformsMeta, ViewMeta};
use super::pipeline::CuboidsPipelines;

use bevy::render::render_resource::BindGroupEntries;
use bevy::{
    prelude::*,
    render::{
        renderer::{RenderDevice, RenderQueue},
        view::ViewUniforms,
    },
};

pub(crate) fn prepare_clipping_planes(
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    mut clipping_plane_uniform: ResMut<UniformBufferOfGpuClippingPlaneRanges>,
) {
    // Values already pushed in extract stage.
    clipping_plane_uniform.write_buffer(&render_device, &render_queue);
}

pub(crate) fn prepare_materials(
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    mut material_uniforms: ResMut<DynamicUniformBufferOfCuboidMaterial>,
) {
    // Values already pushed in extract stage.
    material_uniforms.write_buffer(&render_device, &render_queue);
}

pub(crate) fn prepare_auxiliary_bind_group(
    pipeline: Res<CuboidsPipelines>,
    render_device: Res<RenderDevice>,
    mut aux_meta: ResMut<AuxiliaryMeta>,
    clipping_plane_uniform: Res<UniformBufferOfGpuClippingPlaneRanges>,
    material_uniform: Res<DynamicUniformBufferOfCuboidMaterial>,
) {
    if let (Some(color_binding), Some(planes_binding)) =
        (material_uniform.binding(), clipping_plane_uniform.binding())
    {
        aux_meta.bind_group = Some(render_device.create_bind_group(
            "auxiliary_bind_group",
            &pipeline.aux_layout,
            &BindGroupEntries::sequential((color_binding, planes_binding)),
        ));
    }
}

pub(crate) fn prepare_cuboid_transforms(
    pipeline: Res<CuboidsPipelines>,
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    mut transforms_meta: ResMut<TransformsMeta>,
    mut transform_uniforms: ResMut<DynamicUniformBufferOfCuboidTransforms>,
) {
    let write_transform_buffer_span =
        bevy::log::info_span!("prepare_cuboids::write_transform_buffer");
    write_transform_buffer_span.in_scope(|| {
        transform_uniforms.write_buffer(&render_device, &render_queue);
    });
    if let Some(transforms_binding) = transform_uniforms.binding() {
        let create_bind_group_span = bevy::log::info_span!("prepare_cuboids::create_bind_group");
        transforms_meta.transform_buffer_bind_group = create_bind_group_span.in_scope(|| {
            Some(render_device.create_bind_group(
                "gpu_cuboids_transforms_bind_group",
                &pipeline.transforms_layout,
                &BindGroupEntries::single(transforms_binding),
            ))
        });
    } else {
        assert!(transform_uniforms.is_empty());
    }
}

pub(crate) fn prepare_cuboids(
    pipeline: Res<CuboidsPipelines>,
    render_device: Res<RenderDevice>,
    render_queue: Res<RenderQueue>,
    mut cuboid_buffers: ResMut<CuboidBufferCache>,
) {
    let write_instance_buffer_span =
        bevy::log::info_span!("prepare_cuboids::write_instance_buffer");
    let create_bind_group_span = bevy::log::info_span!("prepare_cuboids::create_bind_group");

    // Write all dirty buffers from the cuboids cache.
    for entry in cuboid_buffers.entries.values_mut() {
        if !entry.dirty {
            assert!(entry.instance_buffer_bind_group.is_some());
            continue;
        }

        write_instance_buffer_span.in_scope(|| {
            entry
                .instance_buffer
                .write_buffer(&render_device, &render_queue);
        });

        entry.instance_buffer_bind_group = create_bind_group_span.in_scope(|| {
            Some(render_device.create_bind_group(
                "cuboids_instance_buffer_bind_group",
                &pipeline.cuboids_layout,
                &BindGroupEntries::single(entry.instance_buffer.binding().unwrap()),
            ))
        });

        entry.dirty = false;
    }
}

pub(crate) fn prepare_cuboids_view_bind_group(
    render_device: Res<RenderDevice>,
    cuboids_pipeline: Res<CuboidsPipelines>,
    mut view_meta: ResMut<ViewMeta>,
    view_uniforms: Res<ViewUniforms>,
) {
    if let Some(view_binding) = view_uniforms.uniforms.binding() {
        view_meta.cuboids_view_bind_group = Some(render_device.create_bind_group(
            "cuboids_view_bind_group",
            &cuboids_pipeline.view_layout,
            &BindGroupEntries::single(view_binding),
        ));
    }
}