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
126

use bevy::{
    prelude::*,
    render::{primitives::Aabb, render_resource::ShaderType},
};

use crate::CuboidMaterialId;

/// Value that determines the color of a [`Cuboid`] based on the associated
/// [`CuboidMaterial`](crate::CuboidMaterial).
pub type Color = u32;

/// Metadata encoded in 32 bits:
///
/// - `0x000000FF`
///     - bit 0 = 0 for visible or 1 for invisible
///     - bit 1 = 0 for non-emissive or 1 for emissive
///     - bits 2-7 = unused
/// - `0x0000FF00` = unused
/// - `0xFFFF0000` = depth bias (u16)
///   - Multiplies the depth of each cuboid vertex by `1 - bias * eps` where
///     `eps = 8e-8`. This can be used with random biases to avoid Z-fighting.
pub type MetaBits = u32;

/// An axis-aligned box, extending from `minimum` to `maximum`.
#[derive(Clone, Copy, Debug, ShaderType)]
#[repr(C)]
pub struct Cuboid {
    pub minimum: Vec3,
    pub meta_bits: MetaBits,
    pub maximum: Vec3,
    pub color: Color,
}

impl Cuboid {
    pub fn new(minimum: Vec3, maximum: Vec3, color: u32) -> Self {
        assert_eq!(std::mem::size_of::<Cuboid>(), 32);
        Self {
            minimum,
            meta_bits: 0,
            maximum,
            color,
        }
    }

    #[inline]
    pub fn make_visible(&mut self) -> &mut Self {
        self.meta_bits &= !1;
        self
    }

    #[inline]
    pub fn make_invisible(&mut self) -> &mut Self {
        self.meta_bits |= 1;
        self
    }

    #[inline]
    pub fn make_emissive(&mut self) -> &mut Self {
        self.meta_bits |= 0b10;
        self
    }

    #[inline]
    pub fn make_non_emissive(&mut self) -> &mut Self {
        self.meta_bits &= !0b10;
        self
    }

    #[inline]
    pub fn set_depth_bias(&mut self, bias: u16) -> &mut Self {
        self.meta_bits &= 0x0000FFFF; // clear
        self.meta_bits |= (bias as u32) << 16; // set
        self
    }
}

/// A set of cuboids to be extracted for rendering.
#[derive(Clone, Component, Debug, Default)]
pub struct Cuboids {
    /// Instances to be rendered.
    pub instances: Vec<Cuboid>,
}

impl Cuboids {
    pub fn new(instances: Vec<Cuboid>) -> Self {
        Self { instances }
    }

    /// Automatically creates an [`Aabb`] that bounds all `instances`.
    pub fn aabb(&self) -> Aabb {
        let mut min = Vec3::splat(f32::MAX);
        let mut max = Vec3::splat(f32::MIN);
        for i in self.instances.iter() {
            min = min.min(i.minimum);
            max = max.max(i.maximum);
        }
        Aabb::from_min_max(min, max)
    }
}

#[derive(Clone, ShaderType)]
pub(crate) struct CuboidsTransform {
    pub matrix: Mat4,
    pub inv_matrix: Mat4,
}

impl CuboidsTransform {
    pub fn new(matrix: Mat4, inv_matrix: Mat4) -> Self {
        Self { matrix, inv_matrix }
    }

    pub fn from_matrix(m: Mat4) -> Self {
        Self::new(m, m.inverse())
    }

    pub fn position(&self) -> Vec3 {
        self.matrix.col(3).truncate()
    }
}

#[derive(Bundle)]
pub struct CuboidsBundle {
    pub material_id: CuboidMaterialId,
    pub cuboids: Cuboids,
    pub spatial: SpatialBundle,
}