From 9d3e7f427092d9d3ca129900ed5f705955200bb6 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Thu, 30 Dec 2021 22:56:38 -0500
Subject: [PATCH 01/11] Initial import from bevy_prototype_particles

---
 Cargo.toml                                  |  11 +
 crates/bevy_internal/Cargo.toml             |   1 +
 crates/bevy_internal/src/default_plugins.rs |   3 +
 crates/bevy_internal/src/lib.rs             |   6 +
 crates/bevy_internal/src/prelude.rs         |   4 +
 crates/bevy_particles/Cargo.toml            |  27 +
 crates/bevy_particles/src/emitter.rs        | 200 ++++++
 crates/bevy_particles/src/lib.rs            |  57 ++
 crates/bevy_particles/src/material.rs       |  98 +++
 crates/bevy_particles/src/modifiers.rs      |  34 +
 crates/bevy_particles/src/particle.wgsl     |  96 +++
 crates/bevy_particles/src/particles.rs      | 334 ++++++++++
 crates/bevy_particles/src/prelude.rs        |   4 +
 crates/bevy_particles/src/render.rs         | 648 ++++++++++++++++++++
 examples/particles/fireball.rs              |  51 ++
 15 files changed, 1574 insertions(+)
 create mode 100644 crates/bevy_particles/Cargo.toml
 create mode 100644 crates/bevy_particles/src/emitter.rs
 create mode 100644 crates/bevy_particles/src/lib.rs
 create mode 100644 crates/bevy_particles/src/material.rs
 create mode 100644 crates/bevy_particles/src/modifiers.rs
 create mode 100644 crates/bevy_particles/src/particle.wgsl
 create mode 100644 crates/bevy_particles/src/particles.rs
 create mode 100644 crates/bevy_particles/src/prelude.rs
 create mode 100644 crates/bevy_particles/src/render.rs
 create mode 100644 examples/particles/fireball.rs

diff --git a/Cargo.toml b/Cargo.toml
index 76b6199116e46..acb114caaba18 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,6 +34,7 @@ dynamic = ["bevy_dylib"]
 # Rendering support
 render = [
   "bevy_internal/bevy_core_pipeline",
+  "bevy_internal/bevy_particles",
   "bevy_internal/bevy_pbr",
   "bevy_internal/bevy_gltf",
   "bevy_internal/bevy_render",
@@ -45,6 +46,11 @@ render = [
 # Optional bevy crates
 bevy_audio = ["bevy_internal/bevy_audio"]
 bevy_core_pipeline = ["bevy_internal/bevy_core_pipeline"]
+bevy_render = ["bevy_internal/bevy_render"]
+bevy_text = ["bevy_internal/bevy_text"]
+bevy_particles = ["bevy_internal/bevy_particles"]
+bevy_pbr = ["bevy_internal/bevy_pbr"]
+bevy_sprite = ["bevy_internal/bevy_sprite"]
 bevy_dynamic_plugin = ["bevy_internal/bevy_dynamic_plugin"]
 bevy_gilrs = ["bevy_internal/bevy_gilrs"]
 bevy_gltf = ["bevy_internal/bevy_gltf"]
@@ -244,6 +250,11 @@ path = "examples/app/thread_pool_resources.rs"
 name = "without_winit"
 path = "examples/app/without_winit.rs"
 
+# Particle Systems
+[[example]]
+name = "particles-fireball"
+path = "examples/particles/fireball.rs"
+
 # Assets
 [[example]]
 name = "asset_loading"
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 064e14b874da1..9962d1cdc7c62 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -72,6 +72,7 @@ bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.5.0" }
 bevy_render = { path = "../bevy_render", optional = true, version = "0.5.0" }
 bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.5.0" }
 bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.5.0" }
+bevy_particles = { path = "../bevy_particles", optional = true, version = "0.5.0" }
 bevy_text = { path = "../bevy_text", optional = true, version = "0.5.0" }
 bevy_ui = { path = "../bevy_ui", optional = true, version = "0.5.0" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index c4a102588d984..a227755bda0a7 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -62,6 +62,9 @@ impl PluginGroup for DefaultPlugins {
 
         #[cfg(feature = "bevy_gilrs")]
         group.add(bevy_gilrs::GilrsPlugin::default());
+
+        #[cfg(feature = "bevy_particles")]
+        group.add(bevy_particles::ParticlePlugin::default());
     }
 }
 
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index dd7d9d58cd11c..8ecde892e5fe1 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -104,6 +104,12 @@ pub mod gltf {
     pub use bevy_gltf::*;
 }
 
+#[cfg(feature = "bevy_particles")]
+pub mod particles {
+    //! Particle systems.
+    pub use bevy_particles::*;
+}
+
 #[cfg(feature = "bevy_pbr")]
 pub mod pbr {
     //! Physically based rendering.
diff --git a/crates/bevy_internal/src/prelude.rs b/crates/bevy_internal/src/prelude.rs
index bddc7dee7dc71..c92affc497389 100644
--- a/crates/bevy_internal/src/prelude.rs
+++ b/crates/bevy_internal/src/prelude.rs
@@ -42,3 +42,7 @@ pub use crate::dynamic_plugin::*;
 #[doc(hidden)]
 #[cfg(feature = "bevy_gilrs")]
 pub use crate::gilrs::*;
+
+#[doc(hidden)]
+#[cfg(feature = "bevy_particles")]
+pub use crate::particles::prelude::*;
diff --git a/crates/bevy_particles/Cargo.toml b/crates/bevy_particles/Cargo.toml
new file mode 100644
index 0000000000000..b342f90b6fa48
--- /dev/null
+++ b/crates/bevy_particles/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "bevy_particles"
+version = "0.5.0"
+edition = "2021"
+description = "Adds particle systems to Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[dependencies]
+rand = { version = "0.8", features = ["small_rng"] }
+wgpu = "0.12"
+bytemuck = { version = "1.7.0", features = ["derive"] }
+bitflags = "1.2"
+
+bevy_app = { path = "../bevy_app" }
+bevy_asset = { path = "../bevy_asset" }
+bevy_crevice = { path = "../bevy_crevice" }
+bevy_core = { path = "../bevy_core" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline" }
+bevy_ecs = { path = "../bevy_ecs" }
+bevy_math = { path = "../bevy_math" }
+bevy_reflect = { path = "../bevy_reflect" }
+bevy_render = { path = "../bevy_render" }
+bevy_tasks = { path = "../bevy_tasks" }
+bevy_transform = { path = "../bevy_transform" }
\ No newline at end of file
diff --git a/crates/bevy_particles/src/emitter.rs b/crates/bevy_particles/src/emitter.rs
new file mode 100644
index 0000000000000..2dbd5d00ea4a8
--- /dev/null
+++ b/crates/bevy_particles/src/emitter.rs
@@ -0,0 +1,200 @@
+use crate::particles::{ParticleParams, Particles};
+use bevy_core::Time;
+use bevy_ecs::prelude::*;
+use bevy_math::*;
+use bevy_render::color::Color;
+use bevy_tasks::ComputeTaskPool;
+use bevy_transform::prelude::*;
+use rand::Rng;
+use std::{ops::Range, time::Duration};
+
+#[derive(Debug, Clone)]
+pub struct EmitterBurst {
+    pub count: Range<usize>,
+    pub wait: Duration,
+}
+
+pub trait EmitterModifier: Send + Sync + 'static {
+    fn modify(&mut self, particle: &mut ParticleParams);
+}
+
+#[derive(Component)]
+pub struct ParticleEmitter {
+    next_burst: Duration,
+    burst_idx: usize,
+    default_params: ParticleParams,
+    default_speed: f32,
+    bursts: Vec<EmitterBurst>,
+    shape: EmitterShape,
+    modifiers: Vec<Box<dyn EmitterModifier>>,
+}
+
+impl ParticleEmitter {
+    pub fn sphere(center: Vec3, radius: f32) -> ParticleEmitterBuilder {
+        ParticleEmitterBuilder::new(EmitterShape::Sphere { center, radius })
+    }
+
+    pub fn hemisphere(center: Vec3, radius: f32) -> ParticleEmitterBuilder {
+        ParticleEmitterBuilder::new(EmitterShape::Hemisphere { center, radius })
+    }
+}
+
+pub struct ParticleEmitterBuilder {
+    default_params: ParticleParams,
+    default_speed: f32,
+    bursts: Vec<EmitterBurst>,
+    shape: EmitterShape,
+    modifiers: Vec<Box<dyn EmitterModifier>>,
+}
+
+impl ParticleEmitterBuilder {
+    fn new(shape: EmitterShape) -> Self {
+        Self {
+            default_params: ParticleParams {
+                size: 1.0,
+                color: Color::WHITE,
+                lifetime: 5.0,
+                ..Default::default()
+            },
+            default_speed: 0.0,
+            bursts: Vec::new(),
+            shape,
+            modifiers: Vec::new(),
+        }
+    }
+
+    pub fn add_burst(mut self, burst: EmitterBurst) -> Self {
+        self.bursts.push(burst);
+        self
+    }
+
+    pub fn add_modifier(mut self, modifier: impl EmitterModifier) -> Self {
+        self.modifiers.push(Box::new(modifier));
+        self
+    }
+
+    pub fn with_default_speed(mut self, speed: f32) -> Self {
+        self.default_speed = speed;
+        self
+    }
+
+    pub fn with_default_color(mut self, color: Color) -> Self {
+        self.default_params.color = color;
+        self
+    }
+
+    pub fn with_default_lifetime(mut self, lifetime: f32) -> Self {
+        self.default_params.lifetime = lifetime;
+        self
+    }
+
+    pub fn with_default_size(mut self, size: f32) -> Self {
+        self.default_params.size = size;
+        self
+    }
+
+    pub fn build(self) -> ParticleEmitter {
+        ParticleEmitter {
+            next_burst: Duration::from_millis(0),
+            burst_idx: 0,
+            default_params: self.default_params,
+            default_speed: self.default_speed,
+            bursts: self.bursts,
+            shape: self.shape,
+            modifiers: self.modifiers,
+        }
+    }
+}
+
+pub enum EmitterShape {
+    Sphere { center: Vec3, radius: f32 },
+    Hemisphere { center: Vec3, radius: f32 },
+}
+
+impl EmitterShape {
+    pub fn sample(&self, rng: &mut impl Rng, params: &mut ParticleParams) {
+        match self {
+            Self::Sphere { radius, center } => Self::sample_sphere(*center, *radius, rng, params),
+            Self::Hemisphere { radius, center } => {
+                Self::sample_hemisphere(*center, *radius, rng, params)
+            }
+        }
+    }
+
+    fn sample_sphere(center: Vec3, radius: f32, rng: &mut impl Rng, params: &mut ParticleParams) {
+        let position = sample_sphere(rng);
+        let r = rng.gen_range(0.0..1.0);
+        params.position = position * r * radius + center;
+        params.velocity = position;
+    }
+
+    fn sample_hemisphere(
+        center: Vec3,
+        radius: f32,
+        rng: &mut impl Rng,
+        params: &mut ParticleParams,
+    ) {
+        let mut position = sample_sphere(rng);
+        position.y = f32::abs(position.y);
+        let r = rng.gen_range(0.0..1.0);
+        params.position = position * r * radius + center;
+        params.velocity = position;
+    }
+}
+
+pub fn emit_particles(
+    time: Res<Time>,
+    compute_task_pool: Res<ComputeTaskPool>,
+    mut particles: Query<(&mut ParticleEmitter, &mut Particles, &GlobalTransform)>,
+) {
+    let delta_time = time.delta();
+    particles.par_for_each_mut(
+        &compute_task_pool,
+        8,
+        |(mut emitter, mut particles, transform)| {
+            let mut remaining = delta_time;
+            let mut rng = rand::thread_rng();
+            let mut total = 0;
+            while remaining > emitter.next_burst {
+                let EmitterBurst { count, wait } = emitter.bursts[emitter.burst_idx].clone();
+                let exact_count = rng.gen_range(count);
+                total += exact_count;
+
+                remaining -= emitter.next_burst;
+
+                emitter.next_burst = wait;
+                emitter.burst_idx = (emitter.burst_idx + 1) % emitter.bursts.len();
+            }
+
+            emitter.next_burst -= remaining;
+
+            if total > 0 {
+                let local_to_world = transform.compute_matrix();
+                let target_capacity = particles.len() + total;
+                particles.reserve(target_capacity);
+                for _ in 0..total {
+                    let mut params = emitter.default_params.clone();
+                    emitter.shape.sample(&mut rng, &mut params);
+                    params.velocity *= emitter.default_speed;
+                    params.position = local_to_world.transform_point3(params.position);
+                    params.velocity = local_to_world.transform_vector3(params.velocity);
+                    for modifier in emitter.modifiers.iter_mut() {
+                        modifier.modify(&mut params);
+                    }
+                    particles.spawn(params);
+                }
+            }
+        },
+    );
+}
+
+/// Select one point at random on the unit sphere.
+fn sample_sphere(rng: &mut impl Rng) -> Vec3 {
+    const TWO_PI: f32 = std::f32::consts::PI * 2.0;
+    let theta = rng.gen_range(0.0..TWO_PI);
+    let z = rng.gen_range(-1.0..1.0);
+    let x = f32::sqrt(1.0 - z * z) * f32::cos(theta);
+    let y = f32::sqrt(1.0 - z * z) * f32::sin(theta);
+
+    Vec3::from((x, y, z))
+}
diff --git a/crates/bevy_particles/src/lib.rs b/crates/bevy_particles/src/lib.rs
new file mode 100644
index 0000000000000..9a302763365fc
--- /dev/null
+++ b/crates/bevy_particles/src/lib.rs
@@ -0,0 +1,57 @@
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_render::{
+    prelude::{ComputedVisibility, Visibility},
+    primitives::Aabb,
+};
+use bevy_transform::prelude::{GlobalTransform, Transform};
+
+pub mod emitter;
+pub mod material;
+pub mod modifiers;
+mod particles;
+pub mod prelude;
+mod render;
+
+pub use emitter::*;
+pub use material::*;
+use modifiers::*;
+pub use particles::*;
+use render::ParticleRenderPlugin;
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq, SystemLabel)]
+pub struct ParticleUpdate;
+
+#[derive(Default)]
+pub struct ParticlePlugin;
+
+impl Plugin for ParticlePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugin(ParticleMaterialPlugin)
+            .add_plugin(ParticleRenderPlugin)
+            .add_system(particles::update_particles.label(ParticleUpdate))
+            .add_system(emitter::emit_particles.after(ParticleUpdate))
+            .register_particle_modifier::<ConstantForce>();
+    }
+}
+
+pub trait ParticleModifierAppExt {
+    fn register_particle_modifier<T: ParticleModifier>(&mut self) -> &mut Self;
+}
+
+impl ParticleModifierAppExt for App {
+    fn register_particle_modifier<T: ParticleModifier>(&mut self) -> &mut Self {
+        self.add_system(modifiers::apply_particle_modifier::<T>.before(ParticleUpdate));
+        self
+    }
+}
+
+#[derive(Bundle, Default)]
+pub struct ParticleBundle {
+    pub particles: Particles,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    pub aabb: Aabb,
+    pub visibility: Visibility,
+    pub computed_visibility: ComputedVisibility,
+}
diff --git a/crates/bevy_particles/src/material.rs b/crates/bevy_particles/src/material.rs
new file mode 100644
index 0000000000000..ff5c2e06478db
--- /dev/null
+++ b/crates/bevy_particles/src/material.rs
@@ -0,0 +1,98 @@
+use bevy_app::{App, Plugin};
+use bevy_asset::{AddAsset, Handle};
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_reflect::TypeUuid;
+use bevy_render::{
+    render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin},
+    render_resource::{
+        std140::{AsStd140, Std140},
+        Buffer, BufferInitDescriptor, BufferUsages,
+    },
+    renderer::RenderDevice,
+    texture::Image,
+};
+
+// NOTE: These must match the bit flags in bevy_pbr2/src/render/pbr.frag!
+bitflags::bitflags! {
+    #[repr(transparent)]
+    struct ParticleMaterialFlags: u32 {
+        const BASE_COLOR_TEXTURE         = (1 << 0);
+        const NONE                       = 0;
+        const UNINITIALIZED              = 0xFFFF;
+    }
+}
+
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "0078f73d-8715-427e-aa65-dc8e1f485d3d"]
+pub struct ParticleMaterial {
+    pub base_color_texture: Option<Handle<Image>>,
+}
+
+impl Default for ParticleMaterial {
+    fn default() -> Self {
+        Self {
+            base_color_texture: None,
+        }
+    }
+}
+
+impl From<Handle<Image>> for ParticleMaterial {
+    fn from(value: Handle<Image>) -> Self {
+        Self {
+            base_color_texture: Some(value),
+            ..Default::default()
+        }
+    }
+}
+
+pub(crate) struct ParticleMaterialPlugin;
+
+impl Plugin for ParticleMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugin(RenderAssetPlugin::<ParticleMaterial>::default())
+            .add_asset::<ParticleMaterial>();
+    }
+}
+
+#[derive(Clone, AsStd140)]
+pub(crate) struct ParticleMaterialUniformData {
+    pub flags: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct GpuParticleMaterial {
+    pub buffer: Buffer,
+    pub base_color_texture: Option<Handle<Image>>,
+}
+
+impl RenderAsset for ParticleMaterial {
+    type ExtractedAsset = ParticleMaterial;
+    type PreparedAsset = GpuParticleMaterial;
+    type Param = SRes<RenderDevice>;
+
+    fn extract_asset(&self) -> Self::ExtractedAsset {
+        self.clone()
+    }
+
+    fn prepare_asset(
+        material: Self::ExtractedAsset,
+        render_device: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
+        let mut flags = ParticleMaterialFlags::NONE;
+        if material.base_color_texture.is_some() {
+            flags |= ParticleMaterialFlags::BASE_COLOR_TEXTURE;
+        }
+        let value = ParticleMaterialUniformData { flags: flags.bits };
+        let value_std140 = value.as_std140();
+
+        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: None,
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+            contents: value_std140.as_bytes(),
+        });
+        Ok(GpuParticleMaterial {
+            buffer,
+            base_color_texture: material.base_color_texture,
+        })
+    }
+}
diff --git a/crates/bevy_particles/src/modifiers.rs b/crates/bevy_particles/src/modifiers.rs
new file mode 100644
index 0000000000000..fcd5083b0723c
--- /dev/null
+++ b/crates/bevy_particles/src/modifiers.rs
@@ -0,0 +1,34 @@
+use crate::Particles;
+use bevy_core::Time;
+use bevy_ecs::prelude::*;
+use bevy_math::*;
+use bevy_tasks::ComputeTaskPool;
+
+pub trait ParticleModifier: Component {
+    fn apply(&self, particles: &mut Particles, delta_time: f32);
+}
+
+#[derive(Component, Debug, Clone)]
+pub struct ConstantForce {
+    pub acceleration_per_second: Vec3,
+}
+
+impl ParticleModifier for ConstantForce {
+    fn apply(&self, particles: &mut Particles, delta_time: f32) {
+        let delta_velocity = Vec4::from((self.acceleration_per_second, 0.0)) * delta_time;
+        for velocity in particles.velocities.iter_mut() {
+            *velocity += delta_velocity;
+        }
+    }
+}
+
+pub fn apply_particle_modifier<T: ParticleModifier>(
+    compute_task_pool: Res<ComputeTaskPool>,
+    time: Res<Time>,
+    mut particles: Query<(&T, &mut Particles)>,
+) {
+    let delta_time = time.delta_seconds_f64() as f32;
+    particles.par_for_each_mut(&compute_task_pool, 8, |(modifier, mut particles)| {
+        modifier.apply(&mut particles, delta_time);
+    });
+}
diff --git a/crates/bevy_particles/src/particle.wgsl b/crates/bevy_particles/src/particle.wgsl
new file mode 100644
index 0000000000000..7a805789d3ae6
--- /dev/null
+++ b/crates/bevy_particles/src/particle.wgsl
@@ -0,0 +1,96 @@
+// TODO: try merging this block with the binding?
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+struct PositionBuffer { data: array<vec4<f32>>; };
+struct SizeBuffer { data: array<f32>; };
+struct ColorBuffer { data: array<vec4<f32>>; };
+
+struct ParticleMaterial {
+  flags: u32;
+};
+
+let FLAGS_BASE_COLOR_TEXTURE_BIT: u32         = 1u;
+
+[[group(1), binding(0)]]
+var<storage, read> positions: PositionBuffer;
+[[group(1), binding(1)]]
+var<storage, read> sizes: SizeBuffer;
+[[group(1), binding(2)]]
+var<storage, read> colors:ColorBuffer;
+[[group(2), binding(0)]]
+var<uniform> material: ParticleMaterial;
+[[group(2), binding(1)]]
+var base_color_texture: texture_2d<f32>;
+[[group(2), binding(2)]]
+var base_color_sampler: sampler;
+
+struct VertexInput {
+  [[builtin(vertex_index)]] vertex_idx: u32;
+};
+
+struct VertexOutput {
+  [[builtin(position)]] position: vec4<f32>;
+  [[location(0)]] color: vec4<f32>;
+  [[location(1)]] uv: vec2<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main(model: VertexInput) -> VertexOutput {
+  let vert_idx = model.vertex_idx % 6u;
+  let particle_idx = model.vertex_idx / 6u;
+
+  // Compute the vertices and UVs of a quad.
+  let tri_vert_idx = vert_idx % 3u;
+  let direction = f32(vert_idx / 3u) - 0.5;
+  let vertex_position = 
+    direction *
+    vec2<f32>(
+      sign(f32(tri_vert_idx & 1u) - 0.5), 
+      sign(f32((tri_vert_idx >> 1u) & 1u) - 0.5)
+    );
+  let uv = vec2<f32>(vertex_position.x + 0.5, -vertex_position.y + 0.5);
+
+  // Uses the view projection matrix to compute the world-space movement directions
+  // TODO: This is actually constant for all billboards and is best done CPU-side.
+  let camera_right = 
+    normalize(vec3<f32>(view.view_proj.x.x, view.view_proj.y.x, view.view_proj.z.x));
+  let camera_up = 
+    normalize(vec3<f32>(view.view_proj.x.y, view.view_proj.y.y, view.view_proj.z.y));
+
+  let particle_position = positions.data[particle_idx].xyz;
+  let theta = positions.data[particle_idx].w;
+  let size = sizes.data[particle_idx];
+  let sin_cos = vec2<f32>(cos(theta), sin(theta));
+  
+  let rotation = mat2x2<f32>(
+    vec2<f32>(sin_cos.x, -sin_cos.y),
+    vec2<f32>(sin_cos.y, sin_cos.x),
+  );
+
+  let vertex_position = rotation * vertex_position;
+
+  var world_space: vec3<f32> = 
+    particle_position + 
+    (camera_right * vertex_position.x * size) + 
+    (camera_up * vertex_position.y * size);
+
+  var out: VertexOutput;
+  out.position = view.view_proj * vec4<f32>(world_space, 1.0);
+  out.color = colors.data[particle_idx];
+  out.uv = uv;
+  return out;
+}
+
+[[stage(fragment)]]
+fn fs_main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
+  var output_color: vec4<f32> = in.color;
+  if ((material.flags & FLAGS_BASE_COLOR_TEXTURE_BIT) != 0u) {
+      output_color = output_color * textureSample(base_color_texture, base_color_sampler, in.uv);
+  }
+  return output_color;
+}
diff --git a/crates/bevy_particles/src/particles.rs b/crates/bevy_particles/src/particles.rs
new file mode 100644
index 0000000000000..06de7fea472af
--- /dev/null
+++ b/crates/bevy_particles/src/particles.rs
@@ -0,0 +1,334 @@
+use bevy_core::Time;
+use bevy_ecs::prelude::*;
+use bevy_math::*;
+use bevy_render::{color::Color, primitives::Aabb};
+use bevy_tasks::ComputeTaskPool;
+use rand::{rngs::SmallRng, Rng, SeedableRng};
+
+#[derive(Debug, Default, Clone)]
+pub struct ParticleParams {
+    pub position: Vec3,
+    pub rotation: f32,
+    pub size: f32,
+    pub velocity: Vec3,
+    pub angular_velocity: f32,
+    pub color: Color,
+    pub lifetime: f32,
+}
+
+#[derive(Debug, Clone)]
+pub struct Particle<'a> {
+    pub position: &'a Vec4,
+    pub size: &'a f32,
+    pub velocity: &'a Vec4,
+    pub color: &'a Vec4,
+    // pub lifetime: &'a f32,
+}
+
+#[derive(Debug)]
+pub struct ParticleMut<'a> {
+    pub position: &'a mut Vec4,
+    pub size: &'a mut f32,
+    pub velocity: &'a mut Vec4,
+    pub color: &'a mut Vec4,
+    // pub lifetime: &'a mut f32,
+}
+
+#[derive(Component, Clone)]
+/// A container component for a batch of particles.
+pub struct Particles {
+    pub(crate) lifetime: f32,
+    // X, Y, Z - world coordinates
+    // W - 1D rotation
+    pub(crate) positions: Vec<Vec4>,
+    pub(crate) colors: Vec<Vec4>,
+    // X, Y, Z - world coordinates
+    // W - 1D rotation
+    pub(crate) velocities: Vec<Vec4>,
+    pub(crate) lerp_factors: Vec<f32>,
+    pub(crate) sizes: Vec<f32>,
+    pub(crate) starts: Vec<f32>,
+    pub(crate) expirations: Vec<f32>,
+    // TODO(james7132): make this user initializable.
+    rng: SmallRng,
+}
+
+impl Default for Particles {
+    fn default() -> Self {
+        Self::new(0)
+    }
+}
+
+impl Particles {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            lifetime: 0.0,
+            positions: Vec::with_capacity(capacity),
+            colors: Vec::with_capacity(capacity),
+            velocities: Vec::with_capacity(capacity),
+            sizes: Vec::with_capacity(capacity),
+            lerp_factors: Vec::with_capacity(capacity),
+            starts: Vec::with_capacity(capacity),
+            expirations: Vec::with_capacity(capacity),
+            rng: SmallRng::from_entropy(),
+        }
+    }
+
+    /// Gets a read-only reference to a particle.
+    ///
+    /// # Panics
+    /// Panics if the provided index is out of bounds.
+    pub fn get<'a>(&'a self, idx: usize) -> Particle<'a> {
+        Particle {
+            position: &self.positions[idx],
+            velocity: &self.velocities[idx],
+            color: &self.colors[idx],
+            size: &self.sizes[idx],
+            // lifetime: &self.lifetimes[idx],
+        }
+    }
+
+    /// Gets a mutable reference to a particle.
+    ///
+    /// # Panics
+    /// Panics if the provided index is out of bounds.
+    pub fn get_mut<'a>(&'a mut self, idx: usize) -> ParticleMut<'a> {
+        ParticleMut {
+            position: &mut self.positions[idx],
+            size: &mut self.sizes[idx],
+            velocity: &mut self.velocities[idx],
+            color: &mut self.colors[idx],
+        }
+    }
+
+    /// Spawns a single particle with the given parameters.
+    ///
+    /// If spawning multiple at the same time, use `spawn_batch` instead.
+    #[inline(always)]
+    pub fn spawn(&mut self, params: ParticleParams) {
+        self.spawn_batch(&[params]);
+    }
+
+    /// Spawns a batch of particles with the given parameters.
+    #[inline(always)]
+    pub fn spawn_batch(&mut self, batch: &[ParticleParams]) {
+        let iterator = batch.into_iter();
+        let new_len = self.len() + batch.len();
+        self.reserve(new_len);
+        unsafe {
+            let len = self.len();
+            for (idx, param) in iterator.enumerate() {
+                self.spawn_unchecked(len + idx, param);
+            }
+            self.flush(new_len);
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn spawn_unchecked(&mut self, idx: usize, params: &ParticleParams) {
+        *self.positions.get_unchecked_mut(idx) = Vec4::from((params.position, params.rotation));
+        *self.velocities.get_unchecked_mut(idx) =
+            Vec4::from((params.velocity, params.angular_velocity));
+        *self.colors.get_unchecked_mut(idx) = params.color.as_rgba_f32().into();
+        *self.sizes.get_unchecked_mut(idx) = params.size;
+        *self.lerp_factors.get_unchecked_mut(idx) = self.rng.gen_range(0.0..1.0);
+        *self.starts.get_unchecked_mut(idx) = self.lifetime;
+        *self.expirations.get_unchecked_mut(idx) = self.lifetime + params.lifetime;
+    }
+
+    /// Consumes another Particles instance and merges in it's particles.
+    pub fn merge(&mut self, batch: impl Into<Particles>) {
+        let batch = batch.into();
+        self.positions.extend(batch.positions);
+        self.velocities.extend(batch.velocities);
+        self.colors.extend(batch.colors);
+        self.sizes.extend(batch.sizes);
+        self.lerp_factors.extend(batch.lerp_factors);
+        self.starts.extend(batch.starts);
+        self.expirations.extend(batch.expirations);
+    }
+
+    pub fn iter<'a>(&'a self) -> ParticleIter<'a> {
+        ParticleIter {
+            idx: 0,
+            particles: self,
+        }
+    }
+
+    pub fn iter_mut<'a>(&'a mut self) -> ParticleIterMut<'a> {
+        ParticleIterMut {
+            idx: 0,
+            particles: self,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.positions.len()
+    }
+
+    pub fn capacity(&self) -> usize {
+        self.positions.capacity()
+    }
+
+    pub fn reserve(&mut self, capacity: usize) {
+        self.positions.reserve(capacity);
+        self.sizes.reserve(capacity);
+        self.lerp_factors.reserve(capacity);
+        self.velocities.reserve(capacity);
+        self.colors.reserve(capacity);
+        self.starts.reserve(capacity);
+        self.expirations.reserve(capacity);
+    }
+
+    pub fn clear(&mut self) {
+        self.lifetime = 0.0;
+        self.positions.clear();
+        self.sizes.clear();
+        self.lerp_factors.clear();
+        self.velocities.clear();
+        self.colors.clear();
+        self.starts.clear();
+        self.expirations.clear();
+    }
+
+    pub fn compute_aabb(&self) -> Option<Aabb> {
+        if self.len() <= 0 {
+            return None;
+        }
+
+        let mut min = Vec4::splat(f32::MAX);
+        let mut max = Vec4::splat(f32::MIN);
+        for position in self.positions.iter() {
+            min = position.min(min);
+            max = position.max(max);
+        }
+        Some(Aabb::from_min_max(min.xyz(), max.xyz()))
+    }
+
+    /// Gets a ratio of how much of a particle's lifetime has passed. Will be 0.0 when the
+    /// particle is newly spawned, and 1.0 or greater when the particle is about to be killed.
+    ///
+    /// # Safety
+    /// `idx` must be a particle index, no bounds checking is done here.
+    pub unsafe fn lifetime_ratio(&self, idx: usize) -> f32 {
+        let start = self.starts.get_unchecked(idx);
+        let end = self.expirations.get_unchecked(idx);
+        (self.lifetime - start) / (end - start)
+    }
+
+    #[inline(always)]
+    pub fn advance_particles(&mut self, delta_time: f32) {
+        self.lifetime += delta_time;
+
+        if self.len() <= 0 {
+            return;
+        }
+
+        let delta_time = Vec4::splat(delta_time);
+        let mut last = self.len() - 1;
+        let mut idx = 0;
+        unsafe {
+            while idx <= last && last > 0 {
+                // SAFE: Both idx and last are always valid indicies
+                if *self.expirations.get_unchecked(last) <= self.lifetime {
+                    // Avoids the copy in the second block.
+                    last -= 1;
+                } else if *self.expirations.get_unchecked(idx) <= self.lifetime {
+                    self.kill(idx, last);
+                    last -= 1;
+                } else {
+                    let position = self.positions.get_unchecked_mut(idx);
+                    let velocity = self.velocities.get_unchecked(idx);
+                    *position += *velocity * delta_time;
+                    idx += 1;
+                }
+            }
+            // SAFE: the set length is always smaller than the original length or underflowed.
+            if last == 0 {
+                self.flush(0);
+            } else {
+                self.flush(last + 1);
+            }
+        }
+    }
+
+    #[inline(always)]
+    unsafe fn kill(&mut self, idx: usize, end: usize) {
+        debug_assert!(idx <= end);
+        *self.positions.get_unchecked_mut(idx) = *self.positions.get_unchecked(end);
+        *self.velocities.get_unchecked_mut(idx) = *self.velocities.get_unchecked(end);
+        *self.colors.get_unchecked_mut(idx) = *self.colors.get_unchecked(end);
+        *self.sizes.get_unchecked_mut(idx) = *self.sizes.get_unchecked(end);
+        *self.lerp_factors.get_unchecked_mut(idx) = *self.lerp_factors.get_unchecked(end);
+        *self.starts.get_unchecked_mut(idx) = *self.starts.get_unchecked(end);
+        *self.expirations.get_unchecked_mut(idx) = *self.expirations.get_unchecked(end);
+    }
+
+    #[inline(always)]
+    unsafe fn flush(&mut self, len: usize) {
+        self.positions.set_len(len);
+        self.velocities.set_len(len);
+        self.colors.set_len(len);
+        self.sizes.set_len(len);
+        self.lerp_factors.set_len(len);
+        self.starts.set_len(len);
+        self.expirations.set_len(len);
+    }
+}
+
+/// An iterator of read-only particles.
+pub struct ParticleIter<'a> {
+    idx: usize,
+    particles: &'a Particles,
+}
+
+impl<'a> Iterator for ParticleIter<'a> {
+    type Item = Particle<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.idx >= self.particles.len() {
+            None
+        } else {
+            let particle = self.particles.get(self.idx);
+            self.idx += 1;
+            Some(particle)
+        }
+    }
+}
+
+/// An iterator of mutable particles.
+pub struct ParticleIterMut<'a> {
+    idx: usize,
+    particles: &'a mut Particles,
+}
+
+impl<'a> Iterator for ParticleIterMut<'a> {
+    type Item = ParticleMut<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.idx >= self.particles.len() {
+            None
+        } else {
+            unsafe {
+                let particles = &mut self.particles;
+                let particle = ParticleMut {
+                    position: &mut *particles.positions.as_mut_ptr().add(self.idx),
+                    size: &mut *particles.sizes.as_mut_ptr().add(self.idx),
+                    velocity: &mut *particles.velocities.as_mut_ptr().add(self.idx),
+                    color: &mut *particles.colors.as_mut_ptr().add(self.idx),
+                };
+                self.idx += 1;
+                Some(particle)
+            }
+        }
+    }
+}
+
+pub fn update_particles(
+    time: Res<Time>,
+    compute_task_pool: Res<ComputeTaskPool>,
+    mut particles: Query<&mut Particles>,
+) {
+    let delta_time = time.delta_seconds_f64() as f32;
+    particles.par_for_each_mut(&compute_task_pool, 8, |mut particles| {
+        particles.advance_particles(delta_time);
+    });
+}
diff --git a/crates/bevy_particles/src/prelude.rs b/crates/bevy_particles/src/prelude.rs
new file mode 100644
index 0000000000000..4b0e6a10f7419
--- /dev/null
+++ b/crates/bevy_particles/src/prelude.rs
@@ -0,0 +1,4 @@
+pub use crate::emitter::{EmitterBurst, ParticleEmitter};
+pub use crate::material::ParticleMaterial;
+pub use crate::modifiers::*;
+pub use crate::{ParticleBundle, Particles};
diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
new file mode 100644
index 0000000000000..401e936df07fb
--- /dev/null
+++ b/crates/bevy_particles/src/render.rs
@@ -0,0 +1,648 @@
+use crate::{
+    material::{ParticleMaterial, ParticleMaterialUniformData},
+    particles::Particles,
+};
+use bevy_app::prelude::*;
+use bevy_asset::{Assets, Handle, HandleUntyped};
+use bevy_core_pipeline::Transparent3d;
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, SystemState},
+};
+use bevy_math::*;
+use bevy_reflect::TypeUuid;
+use bevy_render::{
+    primitives::Aabb,
+    render_asset::RenderAssets,
+    render_phase::{Draw, DrawFunctions, RenderPhase, TrackedRenderPass},
+    render_resource::{std140::AsStd140, *},
+    renderer::{RenderDevice, RenderQueue},
+    texture::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
+    view::{ComputedVisibility, ViewUniform, ViewUniformOffset, ViewUniforms, VisibilitySystems},
+    RenderApp, RenderStage, RenderWorld,
+};
+use bevy_tasks::ComputeTaskPool;
+use bytemuck::Pod;
+use std::{collections::HashMap, num::NonZeroU64, ops::Range};
+use wgpu::{
+    BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindingResource, BufferBinding,
+    FrontFace, ImageCopyTexture, ImageDataLayout, MultisampleState, Origin3d, PolygonMode,
+    PrimitiveState, PrimitiveTopology,
+};
+
+pub const PARTICLE_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3032357527543835453);
+
+pub struct ParticleRenderPlugin;
+
+impl Plugin for ParticleRenderPlugin {
+    fn build(&self, app: &mut App) {
+        let particle_shader = Shader::from_wgsl(include_str!("particle.wgsl"));
+        app.add_system_to_stage(
+            CoreStage::PostUpdate,
+            compute_particles_aabb.label(VisibilitySystems::CalculateBounds),
+        );
+        app.world
+            .get_resource_mut::<Assets<Shader>>()
+            .unwrap()
+            .set_untracked(PARTICLE_SHADER_HANDLE, particle_shader);
+        let render_app = app.get_sub_app_mut(RenderApp).unwrap();
+        render_app
+            .add_system_to_stage(RenderStage::Extract, extract_particles)
+            .add_system_to_stage(RenderStage::Prepare, prepare_particles)
+            .add_system_to_stage(RenderStage::Queue, queue_particles)
+            .init_resource::<ParticlePipeline>()
+            .init_resource::<ParticleMeta>()
+            .init_resource::<ExtractedParticles>()
+            .init_resource::<MaterialBindGroups>()
+            .init_resource::<SpecializedPipelines<ParticlePipeline>>();
+
+        let draw_particle = DrawParticle::new(&mut render_app.world);
+        render_app
+            .world
+            .get_resource::<DrawFunctions<Transparent3d>>()
+            .unwrap()
+            .write()
+            .add(draw_particle);
+    }
+}
+
+struct ParticlePipeline {
+    view_layout: BindGroupLayout,
+    particle_layout: BindGroupLayout,
+    material_layout: BindGroupLayout,
+
+    // This dummy white texture is to be used in place of optional StandardMaterial textures
+    dummy_white_gpu_image: GpuImage,
+}
+
+impl FromWorld for ParticlePipeline {
+    fn from_world(world: &mut World) -> Self {
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+
+        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Uniform,
+                    has_dynamic_offset: true,
+                    min_binding_size: BufferSize::new(std::mem::size_of::<ViewUniform>() as u64),
+                },
+                count: None,
+            }],
+            label: None,
+        });
+
+        let particle_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            label: None,
+            entries: &[
+                // Positions/Rotations
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::VERTEX,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(std::mem::size_of::<Vec4>() as u64),
+                    },
+                    count: None,
+                },
+                // Sizes
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::VERTEX,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(std::mem::size_of::<f32>() as u64),
+                    },
+                    count: None,
+                },
+                // Colors
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::VERTEX,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Storage { read_only: true },
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(std::mem::size_of::<Vec4>() as u64),
+                    },
+                    count: None,
+                },
+            ],
+        });
+
+        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            label: None,
+            entries: &[
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(
+                            ParticleMaterialUniformData::std140_size_static() as u64,
+                        ),
+                    },
+                    count: None,
+                },
+                // Base Color Texture
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Base Color Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+        });
+
+        // A 1x1x1 'all 1.0' texture to use as a dummy texture to use in place of optional StandardMaterial textures
+        let dummy_white_gpu_image = {
+            let image = Image::new_fill(
+                Extent3d::default(),
+                TextureDimension::D2,
+                &[255u8; 4],
+                TextureFormat::bevy_default(),
+            );
+            let texture = render_device.create_texture(&image.texture_descriptor);
+            let sampler = render_device.create_sampler(&image.sampler_descriptor);
+
+            let format_size = image.texture_descriptor.format.pixel_size();
+            let render_queue = world.get_resource_mut::<RenderQueue>().unwrap();
+            render_queue.write_texture(
+                ImageCopyTexture {
+                    texture: &texture,
+                    mip_level: 0,
+                    origin: Origin3d::ZERO,
+                    aspect: TextureAspect::All,
+                },
+                &image.data,
+                ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: Some(
+                        std::num::NonZeroU32::new(
+                            image.texture_descriptor.size.width * format_size as u32,
+                        )
+                        .unwrap(),
+                    ),
+                    rows_per_image: None,
+                },
+                image.texture_descriptor.size,
+            );
+
+            let texture_view = texture.create_view(&TextureViewDescriptor::default());
+            GpuImage {
+                texture,
+                texture_view,
+                sampler,
+            }
+        };
+
+        Self {
+            view_layout,
+            particle_layout,
+            material_layout,
+
+            dummy_white_gpu_image,
+        }
+    }
+}
+
+#[derive(Clone, Eq, Hash, PartialEq)]
+struct ParticlePipelineKey;
+
+impl SpecializedPipeline for ParticlePipeline {
+    type Key = ParticlePipelineKey;
+
+    fn specialize(&self, _: Self::Key) -> RenderPipelineDescriptor {
+        RenderPipelineDescriptor {
+            label: Some("particle_render_pipeline".into()),
+            vertex: VertexState {
+                shader: PARTICLE_SHADER_HANDLE.typed::<Shader>(),
+                entry_point: "vs_main".into(),
+                buffers: vec![],
+                shader_defs: vec![],
+            },
+            fragment: Some(FragmentState {
+                shader: PARTICLE_SHADER_HANDLE.typed::<Shader>(),
+                shader_defs: vec![],
+                entry_point: "fs_main".into(),
+                targets: vec![ColorTargetState {
+                    format: TextureFormat::bevy_default(),
+                    blend: Some(BlendState {
+                        color: BlendComponent {
+                            src_factor: BlendFactor::SrcAlpha,
+                            dst_factor: BlendFactor::OneMinusSrcAlpha,
+                            operation: BlendOperation::Add,
+                        },
+                        alpha: BlendComponent {
+                            src_factor: BlendFactor::One,
+                            dst_factor: BlendFactor::One,
+                            operation: BlendOperation::Add,
+                        },
+                    }),
+                    write_mask: ColorWrites::ALL,
+                }],
+            }),
+            depth_stencil: Some(DepthStencilState {
+                format: TextureFormat::Depth32Float,
+                depth_write_enabled: false,
+                depth_compare: CompareFunction::Greater,
+                stencil: StencilState {
+                    front: StencilFaceState::IGNORE,
+                    back: StencilFaceState::IGNORE,
+                    read_mask: 0,
+                    write_mask: 0,
+                },
+                bias: DepthBiasState {
+                    constant: 0,
+                    slope_scale: 0.0,
+                    clamp: 0.0,
+                },
+            }),
+            layout: Some(vec![
+                self.view_layout.clone(),
+                self.particle_layout.clone(),
+                self.material_layout.clone(),
+            ]),
+            multisample: MultisampleState::default(),
+            primitive: PrimitiveState {
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: FrontFace::Ccw,
+                cull_mode: None,
+                polygon_mode: PolygonMode::Fill,
+                unclipped_depth: false,
+                conservative: false,
+            },
+        }
+    }
+}
+
+fn compute_particles_aabb(
+    compute_task_pool: Res<ComputeTaskPool>,
+    mut query: Query<(&mut Aabb, &Particles)>,
+) {
+    query.par_for_each_mut(&compute_task_pool, 8, |(mut aabb, particles)| {
+        if let Some(bounding_box) = particles.compute_aabb() {
+            *aabb = bounding_box;
+        }
+    });
+}
+
+struct ExtractedParticle {
+    material: Handle<ParticleMaterial>,
+
+    positions: Vec<Vec4>,
+    sizes: Vec<f32>,
+    colors: Vec<Vec4>,
+}
+
+#[derive(Default, Component)]
+struct ExtractedParticles {
+    particles: Vec<ExtractedParticle>,
+}
+
+fn extract_particles(
+    mut render_world: ResMut<RenderWorld>,
+    materials: Res<Assets<ParticleMaterial>>,
+    images: Res<Assets<Image>>,
+    query: Query<(&ComputedVisibility, &Particles, &Handle<ParticleMaterial>)>,
+) {
+    let mut extracted_particles = render_world
+        .get_resource_mut::<ExtractedParticles>()
+        .unwrap();
+    extracted_particles.particles.clear();
+    for (visible, particles, material_handle) in query.iter() {
+        if !visible.is_visible {
+            continue;
+        }
+        if let Some(ref material) = materials.get(material_handle) {
+            if let Some(ref image) = material.base_color_texture {
+                if !images.contains(image) {
+                    continue;
+                }
+            }
+
+            // TODO(james7132): Find a way to do this without
+            extracted_particles.particles.push(ExtractedParticle {
+                material: material_handle.clone_weak(),
+                positions: particles.positions.clone(),
+                sizes: particles.sizes.clone(),
+                colors: particles.colors.clone(),
+            });
+        }
+    }
+}
+
+struct ParticleMeta {
+    ranges: Vec<Range<u64>>,
+    total_count: u64,
+    view_bind_group: Option<BindGroup>,
+    particle_bind_group: Option<BindGroup>,
+
+    positions: BufferVec<Vec4>,
+    sizes: BufferVec<f32>,
+    colors: BufferVec<Vec4>,
+}
+
+impl Default for ParticleMeta {
+    fn default() -> Self {
+        ParticleMeta {
+            ranges: Vec::default(),
+            total_count: 0,
+            view_bind_group: None,
+            particle_bind_group: None,
+
+            positions: BufferVec::new(BufferUsages::STORAGE),
+            sizes: BufferVec::new(BufferUsages::STORAGE),
+            colors: BufferVec::new(BufferUsages::STORAGE),
+        }
+    }
+}
+
+fn prepare_particles(
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut commands: Commands,
+    mut particle_meta: ResMut<ParticleMeta>,
+    mut extracted_particles: ResMut<ExtractedParticles>,
+) {
+    particle_meta.positions.clear();
+    particle_meta.sizes.clear();
+    particle_meta.colors.clear();
+
+    extracted_particles
+        .particles
+        .sort_by(|a, b| a.material.cmp(&b.material));
+
+    let mut total_count = 0;
+    for particle in extracted_particles.particles.iter() {
+        total_count += particle.positions.len();
+    }
+
+    particle_meta.total_count = total_count as u64;
+    particle_meta.ranges.clear();
+    if total_count == 0 {
+        return;
+    }
+
+    particle_meta.positions.reserve(total_count, &render_device);
+    particle_meta.sizes.reserve(total_count, &render_device);
+    particle_meta.colors.reserve(total_count, &render_device);
+
+    let mut start: u32 = 0;
+    let mut end: u32 = 0;
+    let mut current_batch_handle: Option<Handle<ParticleMaterial>> = None;
+    for particle in extracted_particles.particles.iter() {
+        batch_copy(&particle.positions, &mut particle_meta.positions);
+        batch_copy(&particle.sizes, &mut particle_meta.sizes);
+        batch_copy(&particle.colors, &mut particle_meta.colors);
+        end += particle.positions.len() as u32;
+        if let Some(current_batch_handle) = &current_batch_handle {
+            if *current_batch_handle != particle.material {
+                commands.spawn_bundle((ParticleBatch {
+                    range: start..end,
+                    handle: current_batch_handle.clone_weak(),
+                },));
+            }
+            start = end;
+        }
+        current_batch_handle = Some(particle.material.clone_weak());
+    }
+
+    if start != end {
+        if let Some(current_batch_handle) = &current_batch_handle {
+            commands.spawn_bundle((ParticleBatch {
+                range: start..end,
+                handle: current_batch_handle.clone_weak(),
+            },));
+        }
+    }
+
+    particle_meta
+        .positions
+        .write_buffer(&render_device, &render_queue);
+    particle_meta
+        .sizes
+        .write_buffer(&render_device, &render_queue);
+    particle_meta
+        .colors
+        .write_buffer(&render_device, &render_queue);
+}
+
+fn batch_copy<T: Pod>(src: &Vec<T>, dst: &mut BufferVec<T>) {
+    for item in src.iter() {
+        dst.push(*item);
+    }
+}
+
+fn bind_buffer<T: Pod>(buffer: &BufferVec<T>, count: u64) -> BindingResource {
+    BindingResource::Buffer(BufferBinding {
+        buffer: buffer.buffer().expect("missing buffer"),
+        offset: 0,
+        size: Some(NonZeroU64::new(std::mem::size_of::<T>() as u64 * count).unwrap()),
+    })
+}
+
+fn image_handle_to_view_sampler<'a>(
+    particle_pipeline: &'a ParticlePipeline,
+    gpu_images: &'a RenderAssets<Image>,
+    image_option: &Option<Handle<Image>>,
+) -> (&'a TextureView, &'a Sampler) {
+    image_option.as_ref().map_or(
+        (
+            &particle_pipeline.dummy_white_gpu_image.texture_view,
+            &particle_pipeline.dummy_white_gpu_image.sampler,
+        ),
+        |image_handle| {
+            let gpu_image = gpu_images
+                .get(image_handle)
+                .expect("only materials with valid textures should be drawn");
+            (&gpu_image.texture_view, &gpu_image.sampler)
+        },
+    )
+}
+
+#[derive(Component)]
+struct ParticleBatch {
+    range: Range<u32>,
+    handle: Handle<ParticleMaterial>,
+}
+
+#[derive(Default)]
+struct MaterialBindGroups {
+    values: HashMap<Handle<ParticleMaterial>, BindGroup>,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn queue_particles(
+    draw_functions: Res<DrawFunctions<Transparent3d>>,
+    mut views: Query<&mut RenderPhase<Transparent3d>>,
+    render_device: Res<RenderDevice>,
+    mut material_bind_groups: ResMut<MaterialBindGroups>,
+    mut particle_meta: ResMut<ParticleMeta>,
+    view_uniforms: Res<ViewUniforms>,
+    particle_pipeline: Res<ParticlePipeline>,
+    mut pipelines: ResMut<SpecializedPipelines<ParticlePipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    particle_batches: Query<(Entity, &ParticleBatch)>,
+    render_materials: Res<RenderAssets<ParticleMaterial>>,
+    gpu_images: Res<RenderAssets<Image>>,
+) {
+    if view_uniforms.uniforms.is_empty() || particle_meta.total_count == 0 {
+        return;
+    }
+
+    if let Some(view_bindings) = view_uniforms.uniforms.binding() {
+        particle_meta.view_bind_group.get_or_insert_with(|| {
+            render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: view_bindings,
+                }],
+                label: Some("particle_view_bind_group".into()),
+                layout: &particle_pipeline.view_layout,
+            })
+        });
+    }
+
+    // TODO(james7132): Find a way to cache this.
+    particle_meta.particle_bind_group =
+        Some(render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
+                },
+            ],
+            label: Some("particle_particle_bind_group".into()),
+            layout: &particle_pipeline.particle_layout,
+        }));
+
+    // let particle_meta = &mut *particle_meta;
+    let draw_particle_function = draw_functions.read().get_id::<DrawParticle>().unwrap();
+    for mut transparent_phase in views.iter_mut() {
+        for (entity, batch) in particle_batches.iter() {
+            let gpu_material = render_materials
+                .get(&batch.handle)
+                .expect("Failed to get ParticleMaterial PreparedAsset");
+
+            if !material_bind_groups.values.contains_key(&batch.handle) {
+                let (base_color_texture_view, base_color_sampler) = image_handle_to_view_sampler(
+                    &particle_pipeline,
+                    &gpu_images,
+                    &gpu_material.base_color_texture,
+                );
+
+                material_bind_groups.values.insert(
+                    batch.handle.clone_weak(),
+                    render_device.create_bind_group(&BindGroupDescriptor {
+                        entries: &[
+                            BindGroupEntry {
+                                binding: 0,
+                                resource: gpu_material.buffer.as_entire_binding(),
+                            },
+                            BindGroupEntry {
+                                binding: 1,
+                                resource: BindingResource::TextureView(&base_color_texture_view),
+                            },
+                            BindGroupEntry {
+                                binding: 2,
+                                resource: BindingResource::Sampler(&base_color_sampler),
+                            },
+                        ],
+                        label: Some("particle_material_bind_group".into()),
+                        layout: &particle_pipeline.material_layout,
+                    }),
+                );
+            }
+
+            transparent_phase.add(Transparent3d {
+                // TODO(james7132): properly compute this
+                distance: 10.0,
+                pipeline: pipelines.specialize(
+                    &mut pipeline_cache,
+                    &particle_pipeline,
+                    ParticlePipelineKey,
+                ),
+                entity,
+                draw_function: draw_particle_function,
+            });
+        }
+    }
+}
+
+struct DrawParticle {
+    params: SystemState<(
+        SRes<ParticleMeta>,
+        SRes<MaterialBindGroups>,
+        SRes<RenderPipelineCache>,
+        SQuery<Read<ViewUniformOffset>>,
+        SQuery<Read<ParticleBatch>>,
+    )>,
+}
+
+impl DrawParticle {
+    fn new(world: &mut World) -> Self {
+        Self {
+            params: SystemState::new(world),
+        }
+    }
+}
+
+impl Draw<Transparent3d> for DrawParticle {
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &Transparent3d,
+    ) {
+        let (particle_meta, material_bind_groups, pipelines, views, batches) =
+            self.params.get(world);
+        let view_uniform = views.get(view).unwrap();
+        let material_bind_groups = material_bind_groups.into_inner();
+        let particle_meta = particle_meta.into_inner();
+        let batch = batches.get(item.entity).unwrap();
+
+        if let Some(pipeline) = pipelines.into_inner().get(item.pipeline) {
+            let vertex_range = (batch.range.start * 6)..(batch.range.end * 6);
+
+            pass.set_render_pipeline(pipeline);
+            pass.set_bind_group(
+                0,
+                particle_meta.view_bind_group.as_ref().unwrap(),
+                &[view_uniform.offset],
+            );
+            pass.set_bind_group(1, particle_meta.particle_bind_group.as_ref().unwrap(), &[]);
+            pass.set_bind_group(
+                2,
+                material_bind_groups.values.get(&batch.handle).unwrap(),
+                &[],
+            );
+            pass.draw(vertex_range, 0..1);
+        }
+    }
+}
diff --git a/examples/particles/fireball.rs b/examples/particles/fireball.rs
new file mode 100644
index 0000000000000..990370252833f
--- /dev/null
+++ b/examples/particles/fireball.rs
@@ -0,0 +1,51 @@
+use bevy::{particles::modifiers, prelude::*};
+use std::time::Duration;
+
+fn create_scene(mut commands: Commands) {
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
+fn create_particles(mut commands: Commands, mut materials: ResMut<Assets<ParticleMaterial>>) {
+    let particles = Particles::new(1000);
+    commands
+        .spawn()
+        .insert(particles)
+        .insert_bundle(ParticleBundle {
+            transform: Transform {
+                translation: Vec3::from((0.0, -1.0, 0.0)),
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .insert(materials.add(ParticleMaterial {
+            base_color_texture: None,
+        }))
+        .insert(modifiers::ConstantForce {
+            acceleration_per_second: Vec3::from((0.0, 5.0, 0.0)),
+        })
+        .insert(
+            ParticleEmitter::hemisphere(Vec3::ZERO, 1.0)
+                .add_burst(EmitterBurst {
+                    count: 5..10,
+                    wait: Duration::from_millis(1),
+                })
+                .with_default_color(Color::rgba(0.5, 0.5, 0.5, 0.1))
+                .with_default_lifetime(1.5)
+                .with_default_speed(0.3)
+                .with_default_size(0.2)
+                .build(),
+        );
+}
+
+fn main() {
+    App::new()
+        .insert_resource(Msaa { samples: 1 })
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(create_scene)
+        .add_startup_system(create_particles)
+        .run()
+}

From f7f6379b2791c0e55075f3273871e6f4b2b17986 Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Thu, 30 Dec 2021 23:52:10 -0500
Subject: [PATCH 02/11] Address CI failures

---
 crates/bevy_particles/src/material.rs  | 19 +------------------
 crates/bevy_particles/src/particles.rs | 19 +++++++++++--------
 crates/bevy_particles/src/render.rs    | 14 +++++++-------
 examples/README.md                     |  7 +++++++
 4 files changed, 26 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_particles/src/material.rs b/crates/bevy_particles/src/material.rs
index ff5c2e06478db..a67baacf56af4 100644
--- a/crates/bevy_particles/src/material.rs
+++ b/crates/bevy_particles/src/material.rs
@@ -22,29 +22,12 @@ bitflags::bitflags! {
     }
 }
 
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Default, Debug, Clone, TypeUuid)]
 #[uuid = "0078f73d-8715-427e-aa65-dc8e1f485d3d"]
 pub struct ParticleMaterial {
     pub base_color_texture: Option<Handle<Image>>,
 }
 
-impl Default for ParticleMaterial {
-    fn default() -> Self {
-        Self {
-            base_color_texture: None,
-        }
-    }
-}
-
-impl From<Handle<Image>> for ParticleMaterial {
-    fn from(value: Handle<Image>) -> Self {
-        Self {
-            base_color_texture: Some(value),
-            ..Default::default()
-        }
-    }
-}
-
 pub(crate) struct ParticleMaterialPlugin;
 
 impl Plugin for ParticleMaterialPlugin {
diff --git a/crates/bevy_particles/src/particles.rs b/crates/bevy_particles/src/particles.rs
index 06de7fea472af..270c90d569756 100644
--- a/crates/bevy_particles/src/particles.rs
+++ b/crates/bevy_particles/src/particles.rs
@@ -78,7 +78,7 @@ impl Particles {
     ///
     /// # Panics
     /// Panics if the provided index is out of bounds.
-    pub fn get<'a>(&'a self, idx: usize) -> Particle<'a> {
+    pub fn get(&self, idx: usize) -> Particle<'_> {
         Particle {
             position: &self.positions[idx],
             velocity: &self.velocities[idx],
@@ -92,7 +92,7 @@ impl Particles {
     ///
     /// # Panics
     /// Panics if the provided index is out of bounds.
-    pub fn get_mut<'a>(&'a mut self, idx: usize) -> ParticleMut<'a> {
+    pub fn get_mut(&mut self, idx: usize) -> ParticleMut<'_> {
         ParticleMut {
             position: &mut self.positions[idx],
             size: &mut self.sizes[idx],
@@ -112,12 +112,11 @@ impl Particles {
     /// Spawns a batch of particles with the given parameters.
     #[inline(always)]
     pub fn spawn_batch(&mut self, batch: &[ParticleParams]) {
-        let iterator = batch.into_iter();
         let new_len = self.len() + batch.len();
         self.reserve(new_len);
         unsafe {
             let len = self.len();
-            for (idx, param) in iterator.enumerate() {
+            for (idx, param) in batch.iter().enumerate() {
                 self.spawn_unchecked(len + idx, param);
             }
             self.flush(new_len);
@@ -148,20 +147,24 @@ impl Particles {
         self.expirations.extend(batch.expirations);
     }
 
-    pub fn iter<'a>(&'a self) -> ParticleIter<'a> {
+    pub fn iter(&self) -> ParticleIter<'_> {
         ParticleIter {
             idx: 0,
             particles: self,
         }
     }
 
-    pub fn iter_mut<'a>(&'a mut self) -> ParticleIterMut<'a> {
+    pub fn iter_mut(&mut self) -> ParticleIterMut<'_> {
         ParticleIterMut {
             idx: 0,
             particles: self,
         }
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     pub fn len(&self) -> usize {
         self.positions.len()
     }
@@ -192,7 +195,7 @@ impl Particles {
     }
 
     pub fn compute_aabb(&self) -> Option<Aabb> {
-        if self.len() <= 0 {
+        if self.is_empty() {
             return None;
         }
 
@@ -220,7 +223,7 @@ impl Particles {
     pub fn advance_particles(&mut self, delta_time: f32) {
         self.lifetime += delta_time;
 
-        if self.len() <= 0 {
+        if self.is_empty() {
             return;
         }
 
diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index 401e936df07fb..f2975b0c49a3b 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -330,7 +330,7 @@ fn extract_particles(
         if !visible.is_visible {
             continue;
         }
-        if let Some(ref material) = materials.get(material_handle) {
+        if let Some(material) = materials.get(material_handle) {
             if let Some(ref image) = material.base_color_texture {
                 if !images.contains(image) {
                     continue;
@@ -444,7 +444,7 @@ fn prepare_particles(
         .write_buffer(&render_device, &render_queue);
 }
 
-fn batch_copy<T: Pod>(src: &Vec<T>, dst: &mut BufferVec<T>) {
+fn batch_copy<T: Pod>(src: &[T], dst: &mut BufferVec<T>) {
     for item in src.iter() {
         dst.push(*item);
     }
@@ -514,7 +514,7 @@ fn queue_particles(
                     binding: 0,
                     resource: view_bindings,
                 }],
-                label: Some("particle_view_bind_group".into()),
+                label: Some("particle_view_bind_group"),
                 layout: &particle_pipeline.view_layout,
             })
         });
@@ -537,7 +537,7 @@ fn queue_particles(
                     resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
                 },
             ],
-            label: Some("particle_particle_bind_group".into()),
+            label: Some("particle_particle_bind_group"),
             layout: &particle_pipeline.particle_layout,
         }));
 
@@ -566,14 +566,14 @@ fn queue_particles(
                             },
                             BindGroupEntry {
                                 binding: 1,
-                                resource: BindingResource::TextureView(&base_color_texture_view),
+                                resource: BindingResource::TextureView(base_color_texture_view),
                             },
                             BindGroupEntry {
                                 binding: 2,
-                                resource: BindingResource::Sampler(&base_color_sampler),
+                                resource: BindingResource::Sampler(base_color_sampler),
                             },
                         ],
-                        label: Some("particle_material_bind_group".into()),
+                        label: Some("particle_material_bind_group"),
                         layout: &particle_pipeline.material_layout,
                     }),
                 );
diff --git a/examples/README.md b/examples/README.md
index dc8342214f105..b1e1d7d6be51d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -47,6 +47,7 @@ git checkout v0.4.0
   - [ECS (Entity Component System)](#ecs-entity-component-system)
   - [Games](#games)
   - [Input](#input)
+  - [Particle Systems](#particle-systems)
   - [Reflection](#reflection)
   - [Scene](#scene)
   - [Shaders](#shaders)
@@ -180,6 +181,12 @@ Example | File | Description
 `alien_cake_addict` | [`game/alien_cake_addict.rs`](./game/alien_cake_addict.rs) | Eat the cakes. Eat them all. An example 3D game
 `breakout` | [`game/breakout.rs`](./game/breakout.rs) | An implementation of the classic game "Breakout"
 
+## Particle Systems
+
+Example | File | Description
+--- | --- | ---
+`particles-fireball` | [`particles/fireball.rs`](./particles/fireball.rs) | Basic fireball particle system.
+
 ## Input
 
 Example | File | Description

From 8342030302d96f9f5834d3d716de4d9c13685f6d Mon Sep 17 00:00:00 2001
From: james7132 <contact@jamessliu.com>
Date: Fri, 31 Dec 2021 16:31:04 -0500
Subject: [PATCH 03/11] Affix bevy_particles' Bevy dependencies

---
 crates/bevy_particles/Cargo.toml | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/crates/bevy_particles/Cargo.toml b/crates/bevy_particles/Cargo.toml
index b342f90b6fa48..a15da42020e12 100644
--- a/crates/bevy_particles/Cargo.toml
+++ b/crates/bevy_particles/Cargo.toml
@@ -14,14 +14,13 @@ wgpu = "0.12"
 bytemuck = { version = "1.7.0", features = ["derive"] }
 bitflags = "1.2"
 
-bevy_app = { path = "../bevy_app" }
-bevy_asset = { path = "../bevy_asset" }
-bevy_crevice = { path = "../bevy_crevice" }
-bevy_core = { path = "../bevy_core" }
-bevy_core_pipeline = { path = "../bevy_core_pipeline" }
-bevy_ecs = { path = "../bevy_ecs" }
-bevy_math = { path = "../bevy_math" }
-bevy_reflect = { path = "../bevy_reflect" }
-bevy_render = { path = "../bevy_render" }
-bevy_tasks = { path = "../bevy_tasks" }
-bevy_transform = { path = "../bevy_transform" }
\ No newline at end of file
+bevy_app = { path = "../bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../bevy_core", version = "0.5.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.5.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
+bevy_math = { path = "../bevy_math", version = "0.5.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.5.0" }
+bevy_render = { path = "../bevy_render", version = "0.5.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
\ No newline at end of file

From 588d2ed8302c6f907a4a8590da9b6ed6bd989781 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Mon, 3 Jan 2022 18:40:35 -0500
Subject: [PATCH 04/11] Support 2D rendering

---
 crates/bevy_particles/src/render.rs | 280 +++++++++++++++++-----------
 1 file changed, 170 insertions(+), 110 deletions(-)

diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index f2975b0c49a3b..6794e07956388 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -4,7 +4,8 @@ use crate::{
 };
 use bevy_app::prelude::*;
 use bevy_asset::{Assets, Handle, HandleUntyped};
-use bevy_core_pipeline::Transparent3d;
+use bevy_core::FloatOrd;
+use bevy_core_pipeline::{Transparent2d, Transparent3d};
 use bevy_ecs::{
     prelude::*,
     system::{lifetimeless::*, SystemState},
@@ -57,13 +58,21 @@ impl Plugin for ParticleRenderPlugin {
             .init_resource::<MaterialBindGroups>()
             .init_resource::<SpecializedPipelines<ParticlePipeline>>();
 
-        let draw_particle = DrawParticle::new(&mut render_app.world);
+        let draw_2d = DrawParticle::new(&mut render_app.world);
+        render_app
+            .world
+            .get_resource::<DrawFunctions<Transparent2d>>()
+            .unwrap()
+            .write()
+            .add(draw_2d);
+
+        let draw_3d = DrawParticle::new(&mut render_app.world);
         render_app
             .world
             .get_resource::<DrawFunctions<Transparent3d>>()
             .unwrap()
             .write()
-            .add(draw_particle);
+            .add(draw_3d);
     }
 }
 
@@ -349,7 +358,6 @@ fn extract_particles(
 }
 
 struct ParticleMeta {
-    ranges: Vec<Range<u64>>,
     total_count: u64,
     view_bind_group: Option<BindGroup>,
     particle_bind_group: Option<BindGroup>,
@@ -362,7 +370,6 @@ struct ParticleMeta {
 impl Default for ParticleMeta {
     fn default() -> Self {
         ParticleMeta {
-            ranges: Vec::default(),
             total_count: 0,
             view_bind_group: None,
             particle_bind_group: None,
@@ -374,12 +381,61 @@ impl Default for ParticleMeta {
     }
 }
 
+fn build_material_bind_group(
+    current_batch_handle: Handle<ParticleMaterial>,
+    render_device: &RenderDevice,
+    particle_pipeline: &ParticlePipeline,
+    material_bind_groups: &mut MaterialBindGroups,
+    render_materials: &RenderAssets<ParticleMaterial>,
+    gpu_images: &RenderAssets<Image>,
+) {
+    let gpu_material = render_materials
+        .get(&current_batch_handle)
+        .expect("Failed to get ParticleMaterial PreparedAsset");
+
+    if !material_bind_groups.values.contains_key(&current_batch_handle) {
+        let (base_color_texture_view, base_color_sampler) = image_handle_to_view_sampler(
+            &particle_pipeline,
+            gpu_images,
+            &gpu_material.base_color_texture,
+        );
+
+        material_bind_groups.values.insert(
+            current_batch_handle.clone_weak(),
+            render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[
+                    BindGroupEntry {
+                        binding: 0,
+                        resource: gpu_material.buffer.as_entire_binding(),
+                    },
+                    BindGroupEntry {
+                        binding: 1,
+                        resource: BindingResource::TextureView(base_color_texture_view),
+                    },
+                    BindGroupEntry {
+                        binding: 2,
+                        resource: BindingResource::Sampler(base_color_sampler),
+                    },
+                ],
+                label: Some("particle_material_bind_group"),
+                layout: &particle_pipeline.material_layout,
+            }),
+        );
+    }
+
+}
+
 fn prepare_particles(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     mut commands: Commands,
     mut particle_meta: ResMut<ParticleMeta>,
     mut extracted_particles: ResMut<ExtractedParticles>,
+    mut material_bind_groups: ResMut<MaterialBindGroups>,
+    particle_pipeline: Res<ParticlePipeline>,
+    view_uniforms: Res<ViewUniforms>,
+    render_materials: Res<RenderAssets<ParticleMaterial>>,
+    gpu_images: Res<RenderAssets<Image>>,
 ) {
     particle_meta.positions.clear();
     particle_meta.sizes.clear();
@@ -395,14 +451,22 @@ fn prepare_particles(
     }
 
     particle_meta.total_count = total_count as u64;
-    particle_meta.ranges.clear();
-    if total_count == 0 {
+    if view_uniforms.uniforms.is_empty() || total_count == 0 {
         return;
     }
 
-    particle_meta.positions.reserve(total_count, &render_device);
-    particle_meta.sizes.reserve(total_count, &render_device);
-    particle_meta.colors.reserve(total_count, &render_device);
+    if let Some(view_bindings) = view_uniforms.uniforms.binding() {
+        particle_meta.view_bind_group.get_or_insert_with(|| {
+            render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: view_bindings,
+                }],
+                label: Some("particle_view_bind_group"),
+                layout: &particle_pipeline.view_layout,
+            })
+        });
+    }
 
     let mut start: u32 = 0;
     let mut end: u32 = 0;
@@ -418,6 +482,14 @@ fn prepare_particles(
                     range: start..end,
                     handle: current_batch_handle.clone_weak(),
                 },));
+                build_material_bind_group(
+                    current_batch_handle.clone_weak(), 
+                    &render_device, 
+                    &particle_pipeline, 
+                    &mut material_bind_groups, 
+                    &render_materials, 
+                    &gpu_images
+                );
             }
             start = end;
         }
@@ -430,6 +502,14 @@ fn prepare_particles(
                 range: start..end,
                 handle: current_batch_handle.clone_weak(),
             },));
+            build_material_bind_group(
+                current_batch_handle.clone_weak(), 
+                &render_device, 
+                &particle_pipeline, 
+                &mut material_bind_groups, 
+                &render_materials, 
+                &gpu_images
+            );
         }
     }
 
@@ -442,6 +522,28 @@ fn prepare_particles(
     particle_meta
         .colors
         .write_buffer(&render_device, &render_queue);
+
+    // TODO(james7132): Find a way to cache this.
+    particle_meta.particle_bind_group =
+        Some(render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
+                },
+            ],
+            label: Some("particle_particle_bind_group"),
+            layout: &particle_pipeline.particle_layout,
+        }));
+
 }
 
 fn batch_copy<T: Pod>(src: &[T], dst: &mut BufferVec<T>) {
@@ -490,105 +592,39 @@ struct MaterialBindGroups {
 
 #[allow(clippy::too_many_arguments)]
 fn queue_particles(
-    draw_functions: Res<DrawFunctions<Transparent3d>>,
-    mut views: Query<&mut RenderPhase<Transparent3d>>,
-    render_device: Res<RenderDevice>,
-    mut material_bind_groups: ResMut<MaterialBindGroups>,
-    mut particle_meta: ResMut<ParticleMeta>,
-    view_uniforms: Res<ViewUniforms>,
-    particle_pipeline: Res<ParticlePipeline>,
+    draw_functions_2d: Res<DrawFunctions<Transparent2d>>,
+    draw_functions_3d: Res<DrawFunctions<Transparent2d>>,
+    mut views_2d: Query<&mut RenderPhase<Transparent2d>>,
+    mut views_3d: Query<&mut RenderPhase<Transparent3d>>,
     mut pipelines: ResMut<SpecializedPipelines<ParticlePipeline>>,
     mut pipeline_cache: ResMut<RenderPipelineCache>,
-    particle_batches: Query<(Entity, &ParticleBatch)>,
-    render_materials: Res<RenderAssets<ParticleMaterial>>,
-    gpu_images: Res<RenderAssets<Image>>,
+    particle_batches: Query<Entity, With<ParticleBatch>>,
+    particle_pipeline: Res<ParticlePipeline>,
 ) {
-    if view_uniforms.uniforms.is_empty() || particle_meta.total_count == 0 {
-        return;
-    }
-
-    if let Some(view_bindings) = view_uniforms.uniforms.binding() {
-        particle_meta.view_bind_group.get_or_insert_with(|| {
-            render_device.create_bind_group(&BindGroupDescriptor {
-                entries: &[BindGroupEntry {
-                    binding: 0,
-                    resource: view_bindings,
-                }],
-                label: Some("particle_view_bind_group"),
-                layout: &particle_pipeline.view_layout,
-            })
-        });
-    }
-
-    // TODO(james7132): Find a way to cache this.
-    particle_meta.particle_bind_group =
-        Some(render_device.create_bind_group(&BindGroupDescriptor {
-            entries: &[
-                BindGroupEntry {
-                    binding: 0,
-                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 1,
-                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 2,
-                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
-                },
-            ],
-            label: Some("particle_particle_bind_group"),
-            layout: &particle_pipeline.particle_layout,
-        }));
-
-    // let particle_meta = &mut *particle_meta;
-    let draw_particle_function = draw_functions.read().get_id::<DrawParticle>().unwrap();
-    for mut transparent_phase in views.iter_mut() {
-        for (entity, batch) in particle_batches.iter() {
-            let gpu_material = render_materials
-                .get(&batch.handle)
-                .expect("Failed to get ParticleMaterial PreparedAsset");
-
-            if !material_bind_groups.values.contains_key(&batch.handle) {
-                let (base_color_texture_view, base_color_sampler) = image_handle_to_view_sampler(
-                    &particle_pipeline,
-                    &gpu_images,
-                    &gpu_material.base_color_texture,
-                );
-
-                material_bind_groups.values.insert(
-                    batch.handle.clone_weak(),
-                    render_device.create_bind_group(&BindGroupDescriptor {
-                        entries: &[
-                            BindGroupEntry {
-                                binding: 0,
-                                resource: gpu_material.buffer.as_entire_binding(),
-                            },
-                            BindGroupEntry {
-                                binding: 1,
-                                resource: BindingResource::TextureView(base_color_texture_view),
-                            },
-                            BindGroupEntry {
-                                binding: 2,
-                                resource: BindingResource::Sampler(base_color_sampler),
-                            },
-                        ],
-                        label: Some("particle_material_bind_group"),
-                        layout: &particle_pipeline.material_layout,
-                    }),
-                );
-            }
-
-            transparent_phase.add(Transparent3d {
+    let draw_2d = draw_functions_2d.read().get_id::<DrawParticle>().unwrap();
+    let draw_3d = draw_functions_3d.read().get_id::<DrawParticle>().unwrap();
+    for entity in particle_batches.iter() {
+        let pipeline = pipelines.specialize(
+            &mut pipeline_cache,
+            &particle_pipeline,
+            ParticlePipelineKey,
+        );
+        for mut phase in views_2d.iter_mut() {
+            phase.add(Transparent2d {
+                // TODO(james7132): properly compute this
+                sort_key: FloatOrd(0.0),
+                pipeline,
+                entity,
+                draw_function: draw_2d,
+            });
+        }
+        for mut phase in views_3d.iter_mut() {
+            phase.add(Transparent3d {
                 // TODO(james7132): properly compute this
                 distance: 10.0,
-                pipeline: pipelines.specialize(
-                    &mut pipeline_cache,
-                    &particle_pipeline,
-                    ParticlePipelineKey,
-                ),
+                pipeline,
                 entity,
-                draw_function: draw_particle_function,
+                draw_function: draw_3d,
             });
         }
     }
@@ -610,24 +646,24 @@ impl DrawParticle {
             params: SystemState::new(world),
         }
     }
-}
 
-impl Draw<Transparent3d> for DrawParticle {
-    fn draw<'w>(
+    #[inline(always)]
+    fn draw_particles<'w>(
         &mut self,
         world: &'w World,
-        pass: &mut TrackedRenderPass<'w>,
         view: Entity,
-        item: &Transparent3d,
+        pass: &mut TrackedRenderPass<'w>,
+        entity: Entity,
+        pipeline: CachedPipelineId,
     ) {
         let (particle_meta, material_bind_groups, pipelines, views, batches) =
             self.params.get(world);
         let view_uniform = views.get(view).unwrap();
         let material_bind_groups = material_bind_groups.into_inner();
         let particle_meta = particle_meta.into_inner();
-        let batch = batches.get(item.entity).unwrap();
+        let batch = batches.get(entity).unwrap();
 
-        if let Some(pipeline) = pipelines.into_inner().get(item.pipeline) {
+        if let Some(pipeline) = pipelines.into_inner().get(pipeline) {
             let vertex_range = (batch.range.start * 6)..(batch.range.end * 6);
 
             pass.set_render_pipeline(pipeline);
@@ -646,3 +682,27 @@ impl Draw<Transparent3d> for DrawParticle {
         }
     }
 }
+
+impl Draw<Transparent2d> for DrawParticle {
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &Transparent2d,
+    ) {
+        self.draw_particles(world, view, pass, item.entity, item.pipeline);
+    }
+}
+
+impl Draw<Transparent3d> for DrawParticle {
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &Transparent3d,
+    ) {
+        self.draw_particles(world, view, pass, item.entity, item.pipeline);
+    }
+}

From ca1f01c4f38e39318918e43527104adbc2f4a91a Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Tue, 4 Jan 2022 14:22:03 -0500
Subject: [PATCH 05/11] Parallelize queue-phase BindGroup creation

---
 crates/bevy_particles/src/render.rs | 210 +++++++++++++---------------
 1 file changed, 96 insertions(+), 114 deletions(-)

diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index 6794e07956388..d5b455c26cf50 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -34,7 +34,7 @@ use wgpu::{
 pub const PARTICLE_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3032357527543835453);
 
-pub struct ParticleRenderPlugin;
+pub(crate) struct ParticleRenderPlugin;
 
 impl Plugin for ParticleRenderPlugin {
     fn build(&self, app: &mut App) {
@@ -52,6 +52,7 @@ impl Plugin for ParticleRenderPlugin {
             .add_system_to_stage(RenderStage::Extract, extract_particles)
             .add_system_to_stage(RenderStage::Prepare, prepare_particles)
             .add_system_to_stage(RenderStage::Queue, queue_particles)
+            .add_system_to_stage(RenderStage::Queue, queue_particle_bind_groups)
             .init_resource::<ParticlePipeline>()
             .init_resource::<ParticleMeta>()
             .init_resource::<ExtractedParticles>()
@@ -346,7 +347,7 @@ fn extract_particles(
                 }
             }
 
-            // TODO(james7132): Find a way to do this without
+            // TODO(james7132): Find a way to do this without clones.
             extracted_particles.particles.push(ExtractedParticle {
                 material: material_handle.clone_weak(),
                 positions: particles.positions.clone(),
@@ -381,61 +382,12 @@ impl Default for ParticleMeta {
     }
 }
 
-fn build_material_bind_group(
-    current_batch_handle: Handle<ParticleMaterial>,
-    render_device: &RenderDevice,
-    particle_pipeline: &ParticlePipeline,
-    material_bind_groups: &mut MaterialBindGroups,
-    render_materials: &RenderAssets<ParticleMaterial>,
-    gpu_images: &RenderAssets<Image>,
-) {
-    let gpu_material = render_materials
-        .get(&current_batch_handle)
-        .expect("Failed to get ParticleMaterial PreparedAsset");
-
-    if !material_bind_groups.values.contains_key(&current_batch_handle) {
-        let (base_color_texture_view, base_color_sampler) = image_handle_to_view_sampler(
-            &particle_pipeline,
-            gpu_images,
-            &gpu_material.base_color_texture,
-        );
-
-        material_bind_groups.values.insert(
-            current_batch_handle.clone_weak(),
-            render_device.create_bind_group(&BindGroupDescriptor {
-                entries: &[
-                    BindGroupEntry {
-                        binding: 0,
-                        resource: gpu_material.buffer.as_entire_binding(),
-                    },
-                    BindGroupEntry {
-                        binding: 1,
-                        resource: BindingResource::TextureView(base_color_texture_view),
-                    },
-                    BindGroupEntry {
-                        binding: 2,
-                        resource: BindingResource::Sampler(base_color_sampler),
-                    },
-                ],
-                label: Some("particle_material_bind_group"),
-                layout: &particle_pipeline.material_layout,
-            }),
-        );
-    }
-
-}
-
 fn prepare_particles(
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
     mut commands: Commands,
     mut particle_meta: ResMut<ParticleMeta>,
     mut extracted_particles: ResMut<ExtractedParticles>,
-    mut material_bind_groups: ResMut<MaterialBindGroups>,
-    particle_pipeline: Res<ParticlePipeline>,
-    view_uniforms: Res<ViewUniforms>,
-    render_materials: Res<RenderAssets<ParticleMaterial>>,
-    gpu_images: Res<RenderAssets<Image>>,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
 ) {
     particle_meta.positions.clear();
     particle_meta.sizes.clear();
@@ -445,51 +397,22 @@ fn prepare_particles(
         .particles
         .sort_by(|a, b| a.material.cmp(&b.material));
 
-    let mut total_count = 0;
-    for particle in extracted_particles.particles.iter() {
-        total_count += particle.positions.len();
-    }
-
-    particle_meta.total_count = total_count as u64;
-    if view_uniforms.uniforms.is_empty() || total_count == 0 {
-        return;
-    }
-
-    if let Some(view_bindings) = view_uniforms.uniforms.binding() {
-        particle_meta.view_bind_group.get_or_insert_with(|| {
-            render_device.create_bind_group(&BindGroupDescriptor {
-                entries: &[BindGroupEntry {
-                    binding: 0,
-                    resource: view_bindings,
-                }],
-                label: Some("particle_view_bind_group"),
-                layout: &particle_pipeline.view_layout,
-            })
-        });
-    }
-
     let mut start: u32 = 0;
     let mut end: u32 = 0;
     let mut current_batch_handle: Option<Handle<ParticleMaterial>> = None;
+    particle_meta.total_count = 0;
     for particle in extracted_particles.particles.iter() {
         batch_copy(&particle.positions, &mut particle_meta.positions);
         batch_copy(&particle.sizes, &mut particle_meta.sizes);
         batch_copy(&particle.colors, &mut particle_meta.colors);
         end += particle.positions.len() as u32;
+        particle_meta.total_count += particle.positions.len() as u64;
         if let Some(current_batch_handle) = &current_batch_handle {
             if *current_batch_handle != particle.material {
                 commands.spawn_bundle((ParticleBatch {
                     range: start..end,
                     handle: current_batch_handle.clone_weak(),
                 },));
-                build_material_bind_group(
-                    current_batch_handle.clone_weak(), 
-                    &render_device, 
-                    &particle_pipeline, 
-                    &mut material_bind_groups, 
-                    &render_materials, 
-                    &gpu_images
-                );
             }
             start = end;
         }
@@ -502,17 +425,13 @@ fn prepare_particles(
                 range: start..end,
                 handle: current_batch_handle.clone_weak(),
             },));
-            build_material_bind_group(
-                current_batch_handle.clone_weak(), 
-                &render_device, 
-                &particle_pipeline, 
-                &mut material_bind_groups, 
-                &render_materials, 
-                &gpu_images
-            );
         }
     }
 
+    if particle_meta.total_count == 0 {
+        return;
+    }
+
     particle_meta
         .positions
         .write_buffer(&render_device, &render_queue);
@@ -522,28 +441,6 @@ fn prepare_particles(
     particle_meta
         .colors
         .write_buffer(&render_device, &render_queue);
-
-    // TODO(james7132): Find a way to cache this.
-    particle_meta.particle_bind_group =
-        Some(render_device.create_bind_group(&BindGroupDescriptor {
-            entries: &[
-                BindGroupEntry {
-                    binding: 0,
-                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 1,
-                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 2,
-                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
-                },
-            ],
-            label: Some("particle_particle_bind_group"),
-            layout: &particle_pipeline.particle_layout,
-        }));
-
 }
 
 fn batch_copy<T: Pod>(src: &[T], dst: &mut BufferVec<T>) {
@@ -590,6 +487,91 @@ struct MaterialBindGroups {
     values: HashMap<Handle<ParticleMaterial>, BindGroup>,
 }
 
+fn queue_particle_bind_groups(
+    mut particle_meta: ResMut<ParticleMeta>,
+    mut material_bind_groups: ResMut<MaterialBindGroups>,
+    view_uniforms: Res<ViewUniforms>,
+    render_device: Res<RenderDevice>,
+    particle_batches: Query<&ParticleBatch>,
+    particle_pipeline: Res<ParticlePipeline>,
+    render_materials: Res<RenderAssets<ParticleMaterial>>,
+    gpu_images: Res<RenderAssets<Image>>,
+) {
+    if view_uniforms.uniforms.is_empty() || particle_meta.total_count == 0 {
+        return;
+    }
+
+    if let Some(view_bindings) = view_uniforms.uniforms.binding() {
+        particle_meta.view_bind_group.get_or_insert_with(|| {
+            render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: view_bindings,
+                }],
+                label: Some("particle_view_bind_group"),
+                layout: &particle_pipeline.view_layout,
+            })
+        });
+    }
+
+    // TODO(james7132): Find a way to cache this.
+    particle_meta.particle_bind_group =
+        Some(render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
+                },
+            ],
+            label: Some("particle_particle_bind_group"),
+            layout: &particle_pipeline.particle_layout,
+        }));
+
+    for batch in particle_batches.iter() {
+        let gpu_material = render_materials
+            .get(&batch.handle)
+            .expect("Failed to get ParticleMaterial PreparedAsset");
+
+        if !material_bind_groups.values.contains_key(&batch.handle) {
+            let (base_color_texture_view, base_color_sampler) = image_handle_to_view_sampler(
+                &particle_pipeline,
+                &gpu_images,
+                &gpu_material.base_color_texture,
+            );
+
+            material_bind_groups.values.insert(
+                batch.handle.clone_weak(),
+                render_device.create_bind_group(&BindGroupDescriptor {
+                    entries: &[
+                        BindGroupEntry {
+                            binding: 0,
+                            resource: gpu_material.buffer.as_entire_binding(),
+                        },
+                        BindGroupEntry {
+                            binding: 1,
+                            resource: BindingResource::TextureView(base_color_texture_view),
+                        },
+                        BindGroupEntry {
+                            binding: 2,
+                            resource: BindingResource::Sampler(base_color_sampler),
+                        },
+                    ],
+                    label: Some("particle_material_bind_group"),
+                    layout: &particle_pipeline.material_layout,
+                }),
+            );
+        }
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 fn queue_particles(
     draw_functions_2d: Res<DrawFunctions<Transparent2d>>,

From c304a1e6d45e5c6d1dc1de4cad2a6f9dac9bd412 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Tue, 4 Jan 2022 15:14:11 -0500
Subject: [PATCH 06/11] Fix formatting

---
 Cargo.toml                          | 4 ----
 crates/bevy_particles/src/render.rs | 7 ++-----
 2 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index acb114caaba18..543014ae8c225 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,11 +46,7 @@ render = [
 # Optional bevy crates
 bevy_audio = ["bevy_internal/bevy_audio"]
 bevy_core_pipeline = ["bevy_internal/bevy_core_pipeline"]
-bevy_render = ["bevy_internal/bevy_render"]
-bevy_text = ["bevy_internal/bevy_text"]
 bevy_particles = ["bevy_internal/bevy_particles"]
-bevy_pbr = ["bevy_internal/bevy_pbr"]
-bevy_sprite = ["bevy_internal/bevy_sprite"]
 bevy_dynamic_plugin = ["bevy_internal/bevy_dynamic_plugin"]
 bevy_gilrs = ["bevy_internal/bevy_gilrs"]
 bevy_gltf = ["bevy_internal/bevy_gltf"]
diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index d5b455c26cf50..c701729e06e9c 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -586,11 +586,8 @@ fn queue_particles(
     let draw_2d = draw_functions_2d.read().get_id::<DrawParticle>().unwrap();
     let draw_3d = draw_functions_3d.read().get_id::<DrawParticle>().unwrap();
     for entity in particle_batches.iter() {
-        let pipeline = pipelines.specialize(
-            &mut pipeline_cache,
-            &particle_pipeline,
-            ParticlePipelineKey,
-        );
+        let pipeline =
+            pipelines.specialize(&mut pipeline_cache, &particle_pipeline, ParticlePipelineKey);
         for mut phase in views_2d.iter_mut() {
             phase.add(Transparent2d {
                 // TODO(james7132): properly compute this

From 089a5d0160a056fcb2c58c2f966df4899600a496 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Wed, 5 Jan 2022 01:02:49 -0500
Subject: [PATCH 07/11] Implement visibility-based simulation of particles

---
 crates/bevy_particles/src/lib.rs       |   9 +++
 crates/bevy_particles/src/particles.rs | 100 +++++++++++++++++++++++--
 2 files changed, 103 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_particles/src/lib.rs b/crates/bevy_particles/src/lib.rs
index 9a302763365fc..d3c37a4bd96d3 100644
--- a/crates/bevy_particles/src/lib.rs
+++ b/crates/bevy_particles/src/lib.rs
@@ -3,6 +3,7 @@ use bevy_ecs::prelude::*;
 use bevy_render::{
     prelude::{ComputedVisibility, Visibility},
     primitives::Aabb,
+    view::VisibilitySystems,
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
 
@@ -31,6 +32,14 @@ impl Plugin for ParticlePlugin {
             .add_plugin(ParticleRenderPlugin)
             .add_system(particles::update_particles.label(ParticleUpdate))
             .add_system(emitter::emit_particles.after(ParticleUpdate))
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                particles::compute_particles_aabb.label(VisibilitySystems::CalculateBounds),
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                particles::cull_particles.after(VisibilitySystems::CheckVisibility),
+            )
             .register_particle_modifier::<ConstantForce>();
     }
 }
diff --git a/crates/bevy_particles/src/particles.rs b/crates/bevy_particles/src/particles.rs
index 270c90d569756..323d96e64dfa7 100644
--- a/crates/bevy_particles/src/particles.rs
+++ b/crates/bevy_particles/src/particles.rs
@@ -1,7 +1,7 @@
 use bevy_core::Time;
 use bevy_ecs::prelude::*;
 use bevy_math::*;
-use bevy_render::{color::Color, primitives::Aabb};
+use bevy_render::{color::Color, primitives::Aabb, view::ComputedVisibility};
 use bevy_tasks::ComputeTaskPool;
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 
@@ -34,9 +34,43 @@ pub struct ParticleMut<'a> {
     // pub lifetime: &'a mut f32,
 }
 
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum ParticleSystemState {
+    Playing,
+    Paused,
+    Stopped,
+}
+
+impl ParticleSystemState {
+    #[inline(always)]
+    pub fn is_playing(&self) -> bool {
+        matches!(self, Self::Playing)
+    }
+
+    #[inline(always)]
+    pub fn is_paused(&self) -> bool {
+        matches!(self, Self::Playing)
+    }
+
+    #[inline(always)]
+    pub fn is_stopped(&self) -> bool {
+        matches!(self, Self::Playing)
+    }
+}
+
+#[repr(u8)]
+#[derive(Debug, Clone, Copy)]
+pub enum ParticleSystemCullingMode {
+    Pause,
+    AlwaysSimulate,
+}
+
 #[derive(Component, Clone)]
 /// A container component for a batch of particles.
 pub struct Particles {
+    state: ParticleSystemState,
+    culling_mode: ParticleSystemCullingMode,
     pub(crate) lifetime: f32,
     // X, Y, Z - world coordinates
     // W - 1D rotation
@@ -62,6 +96,8 @@ impl Default for Particles {
 impl Particles {
     pub fn new(capacity: usize) -> Self {
         Self {
+            state: ParticleSystemState::Playing,
+            culling_mode: ParticleSystemCullingMode::Pause,
             lifetime: 0.0,
             positions: Vec::with_capacity(capacity),
             colors: Vec::with_capacity(capacity),
@@ -101,6 +137,22 @@ impl Particles {
         }
     }
 
+    pub fn state(&self) -> ParticleSystemState {
+        self.state
+    }
+
+    pub fn set_state(&mut self, state: ParticleSystemState) {
+        self.state = state;
+    }
+
+    pub fn culling_mode(&self) -> ParticleSystemCullingMode {
+        self.culling_mode
+    }
+
+    pub fn set_culling_mode(&mut self, culling_mode: ParticleSystemCullingMode) {
+        self.culling_mode = culling_mode;
+    }
+
     /// Spawns a single particle with the given parameters.
     ///
     /// If spawning multiple at the same time, use `spawn_batch` instead.
@@ -161,14 +213,17 @@ impl Particles {
         }
     }
 
+    #[inline(always)]
     pub fn is_empty(&self) -> bool {
-        self.len() == 0
+        self.positions.is_empty()
     }
 
+    #[inline(always)]
     pub fn len(&self) -> usize {
         self.positions.len()
     }
 
+    #[inline(always)]
     pub fn capacity(&self) -> usize {
         self.positions.capacity()
     }
@@ -221,12 +276,11 @@ impl Particles {
 
     #[inline(always)]
     pub fn advance_particles(&mut self, delta_time: f32) {
-        self.lifetime += delta_time;
-
-        if self.is_empty() {
+        if self.is_empty() || !self.state.is_playing() {
             return;
         }
 
+        self.lifetime += delta_time;
         let delta_time = Vec4::splat(delta_time);
         let mut last = self.len() - 1;
         let mut idx = 0;
@@ -277,6 +331,21 @@ impl Particles {
         self.starts.set_len(len);
         self.expirations.set_len(len);
     }
+
+    fn on_visibility_change(&mut self, is_visible: bool) {
+        match self.culling_mode {
+            ParticleSystemCullingMode::Pause => {
+                if is_visible {
+                    self.set_state(ParticleSystemState::Playing);
+                } else {
+                    self.set_state(ParticleSystemState::Paused);
+                }
+            }
+            ParticleSystemCullingMode::AlwaysSimulate => {
+                // Always simulate, ignore visibility changes.
+            }
+        }
+    }
 }
 
 /// An iterator of read-only particles.
@@ -325,7 +394,7 @@ impl<'a> Iterator for ParticleIterMut<'a> {
     }
 }
 
-pub fn update_particles(
+pub(crate) fn update_particles(
     time: Res<Time>,
     compute_task_pool: Res<ComputeTaskPool>,
     mut particles: Query<&mut Particles>,
@@ -335,3 +404,22 @@ pub fn update_particles(
         particles.advance_particles(delta_time);
     });
 }
+
+pub(crate) fn compute_particles_aabb(
+    compute_task_pool: Res<ComputeTaskPool>,
+    mut query: Query<(&mut Aabb, &Particles), Changed<Particles>>,
+) {
+    query.par_for_each_mut(&compute_task_pool, 8, |(mut aabb, particles)| {
+        if let Some(bounding_box) = particles.compute_aabb() {
+            *aabb = bounding_box;
+        }
+    });
+}
+
+pub(crate) fn cull_particles(
+    mut particles: Query<(&ComputedVisibility, &mut Particles), Changed<ComputedVisibility>>,
+) {
+    particles.for_each_mut(|(visiblity, mut particles)| {
+        particles.on_visibility_change(visiblity.is_visible);
+    });
+}

From 716694a571a3bb253d4a730860b1c4a7097a55f6 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Wed, 5 Jan 2022 01:19:25 -0500
Subject: [PATCH 08/11] Prevent modifiers and emitters from running while the
 ssytem is not playing.

---
 crates/bevy_particles/src/emitter.rs   | 4 ++++
 crates/bevy_particles/src/modifiers.rs | 8 +++++---
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_particles/src/emitter.rs b/crates/bevy_particles/src/emitter.rs
index 2dbd5d00ea4a8..960c9440aa6e9 100644
--- a/crates/bevy_particles/src/emitter.rs
+++ b/crates/bevy_particles/src/emitter.rs
@@ -152,6 +152,10 @@ pub fn emit_particles(
         &compute_task_pool,
         8,
         |(mut emitter, mut particles, transform)| {
+            if !particles.state().is_playing() {
+                return;
+            }
+
             let mut remaining = delta_time;
             let mut rng = rand::thread_rng();
             let mut total = 0;
diff --git a/crates/bevy_particles/src/modifiers.rs b/crates/bevy_particles/src/modifiers.rs
index fcd5083b0723c..668e42a971fcf 100644
--- a/crates/bevy_particles/src/modifiers.rs
+++ b/crates/bevy_particles/src/modifiers.rs
@@ -22,13 +22,15 @@ impl ParticleModifier for ConstantForce {
     }
 }
 
-pub fn apply_particle_modifier<T: ParticleModifier>(
+pub(crate) fn apply_particle_modifier<T: ParticleModifier>(
     compute_task_pool: Res<ComputeTaskPool>,
     time: Res<Time>,
-    mut particles: Query<(&T, &mut Particles)>,
+    mut particles: Query<(&T, &mut Particles), Changed<Particles>>,
 ) {
     let delta_time = time.delta_seconds_f64() as f32;
     particles.par_for_each_mut(&compute_task_pool, 8, |(modifier, mut particles)| {
-        modifier.apply(&mut particles, delta_time);
+        if particles.state().is_playing() {
+            modifier.apply(&mut particles, delta_time);
+        }
     });
 }

From c1a32763cc5a6bfd7f7b5838d60cadd4b534574b Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Wed, 5 Jan 2022 01:23:25 -0500
Subject: [PATCH 09/11] Shut up clippy

---
 crates/bevy_particles/src/render.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index c701729e06e9c..6a2665fc6d03d 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -487,6 +487,7 @@ struct MaterialBindGroups {
     values: HashMap<Handle<ParticleMaterial>, BindGroup>,
 }
 
+#[allow(clippy::too_many_arguments)]
 fn queue_particle_bind_groups(
     mut particle_meta: ResMut<ParticleMeta>,
     mut material_bind_groups: ResMut<MaterialBindGroups>,

From 8ed1196151121ed5c4985f3a45898bf72ec170ca Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Wed, 5 Jan 2022 12:50:17 -0500
Subject: [PATCH 10/11] Use shader defs instead of bitflags

---
 crates/bevy_particles/src/material.rs   | 31 +++------------
 crates/bevy_particles/src/particle.wgsl | 16 ++------
 crates/bevy_particles/src/render.rs     | 51 ++++++++++---------------
 3 files changed, 30 insertions(+), 68 deletions(-)

diff --git a/crates/bevy_particles/src/material.rs b/crates/bevy_particles/src/material.rs
index a67baacf56af4..31a6c5f29c0e2 100644
--- a/crates/bevy_particles/src/material.rs
+++ b/crates/bevy_particles/src/material.rs
@@ -1,21 +1,15 @@
 use bevy_app::{App, Plugin};
 use bevy_asset::{AddAsset, Handle};
-use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_ecs::system::SystemParamItem;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin},
-    render_resource::{
-        std140::{AsStd140, Std140},
-        Buffer, BufferInitDescriptor, BufferUsages,
-    },
-    renderer::RenderDevice,
     texture::Image,
 };
 
 // NOTE: These must match the bit flags in bevy_pbr2/src/render/pbr.frag!
 bitflags::bitflags! {
-    #[repr(transparent)]
-    struct ParticleMaterialFlags: u32 {
+    pub(crate) struct ParticleMaterialFlags: u32 {
         const BASE_COLOR_TEXTURE         = (1 << 0);
         const NONE                       = 0;
         const UNINITIALIZED              = 0xFFFF;
@@ -37,21 +31,16 @@ impl Plugin for ParticleMaterialPlugin {
     }
 }
 
-#[derive(Clone, AsStd140)]
-pub(crate) struct ParticleMaterialUniformData {
-    pub flags: u32,
-}
-
 #[derive(Debug, Clone)]
 pub struct GpuParticleMaterial {
-    pub buffer: Buffer,
+    pub(crate) flags: ParticleMaterialFlags,
     pub base_color_texture: Option<Handle<Image>>,
 }
 
 impl RenderAsset for ParticleMaterial {
     type ExtractedAsset = ParticleMaterial;
     type PreparedAsset = GpuParticleMaterial;
-    type Param = SRes<RenderDevice>;
+    type Param = ();
 
     fn extract_asset(&self) -> Self::ExtractedAsset {
         self.clone()
@@ -59,22 +48,14 @@ impl RenderAsset for ParticleMaterial {
 
     fn prepare_asset(
         material: Self::ExtractedAsset,
-        render_device: &mut SystemParamItem<Self::Param>,
+        _: &mut SystemParamItem<Self::Param>,
     ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
         let mut flags = ParticleMaterialFlags::NONE;
         if material.base_color_texture.is_some() {
             flags |= ParticleMaterialFlags::BASE_COLOR_TEXTURE;
         }
-        let value = ParticleMaterialUniformData { flags: flags.bits };
-        let value_std140 = value.as_std140();
-
-        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
-            label: None,
-            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
-            contents: value_std140.as_bytes(),
-        });
         Ok(GpuParticleMaterial {
-            buffer,
+            flags,
             base_color_texture: material.base_color_texture,
         })
     }
diff --git a/crates/bevy_particles/src/particle.wgsl b/crates/bevy_particles/src/particle.wgsl
index 7a805789d3ae6..51e733703d198 100644
--- a/crates/bevy_particles/src/particle.wgsl
+++ b/crates/bevy_particles/src/particle.wgsl
@@ -10,12 +10,6 @@ struct PositionBuffer { data: array<vec4<f32>>; };
 struct SizeBuffer { data: array<f32>; };
 struct ColorBuffer { data: array<vec4<f32>>; };
 
-struct ParticleMaterial {
-  flags: u32;
-};
-
-let FLAGS_BASE_COLOR_TEXTURE_BIT: u32         = 1u;
-
 [[group(1), binding(0)]]
 var<storage, read> positions: PositionBuffer;
 [[group(1), binding(1)]]
@@ -23,10 +17,8 @@ var<storage, read> sizes: SizeBuffer;
 [[group(1), binding(2)]]
 var<storage, read> colors:ColorBuffer;
 [[group(2), binding(0)]]
-var<uniform> material: ParticleMaterial;
-[[group(2), binding(1)]]
 var base_color_texture: texture_2d<f32>;
-[[group(2), binding(2)]]
+[[group(2), binding(1)]]
 var base_color_sampler: sampler;
 
 struct VertexInput {
@@ -89,8 +81,8 @@ fn vs_main(model: VertexInput) -> VertexOutput {
 [[stage(fragment)]]
 fn fs_main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
   var output_color: vec4<f32> = in.color;
-  if ((material.flags & FLAGS_BASE_COLOR_TEXTURE_BIT) != 0u) {
-      output_color = output_color * textureSample(base_color_texture, base_color_sampler, in.uv);
-  }
+#ifdef BASE_COLOR_TEXTURE
+  output_color = output_color * textureSample(base_color_texture, base_color_sampler, in.uv);
+#endif
   return output_color;
 }
diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index 6a2665fc6d03d..c580a2224dc9b 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -1,5 +1,5 @@
 use crate::{
-    material::{ParticleMaterial, ParticleMaterialUniformData},
+    material::{ParticleMaterial, ParticleMaterialFlags},
     particles::Particles,
 };
 use bevy_app::prelude::*;
@@ -16,7 +16,7 @@ use bevy_render::{
     primitives::Aabb,
     render_asset::RenderAssets,
     render_phase::{Draw, DrawFunctions, RenderPhase, TrackedRenderPass},
-    render_resource::{std140::AsStd140, *},
+    render_resource::*,
     renderer::{RenderDevice, RenderQueue},
     texture::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
     view::{ComputedVisibility, ViewUniform, ViewUniformOffset, ViewUniforms, VisibilitySystems},
@@ -146,21 +146,9 @@ impl FromWorld for ParticlePipeline {
         let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             label: None,
             entries: &[
-                BindGroupLayoutEntry {
-                    binding: 0,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Uniform,
-                        has_dynamic_offset: false,
-                        min_binding_size: BufferSize::new(
-                            ParticleMaterialUniformData::std140_size_static() as u64,
-                        ),
-                    },
-                    count: None,
-                },
                 // Base Color Texture
                 BindGroupLayoutEntry {
-                    binding: 1,
+                    binding: 0,
                     visibility: ShaderStages::FRAGMENT,
                     ty: BindingType::Texture {
                         multisampled: false,
@@ -171,7 +159,7 @@ impl FromWorld for ParticlePipeline {
                 },
                 // Base Color Texture Sampler
                 BindGroupLayoutEntry {
-                    binding: 2,
+                    binding: 1,
                     visibility: ShaderStages::FRAGMENT,
                     ty: BindingType::Sampler(SamplerBindingType::Filtering),
                     count: None,
@@ -231,24 +219,25 @@ impl FromWorld for ParticlePipeline {
     }
 }
 
-#[derive(Clone, Eq, Hash, PartialEq)]
-struct ParticlePipelineKey;
-
 impl SpecializedPipeline for ParticlePipeline {
-    type Key = ParticlePipelineKey;
+    type Key = ParticleMaterialFlags;
 
-    fn specialize(&self, _: Self::Key) -> RenderPipelineDescriptor {
+    fn specialize(&self, flags: Self::Key) -> RenderPipelineDescriptor {
+        let mut shader_defs = Vec::new();
+        if flags.contains(ParticleMaterialFlags::BASE_COLOR_TEXTURE) {
+            shader_defs.push("BASE_COLOR_TEXTURE".into());
+        }
         RenderPipelineDescriptor {
             label: Some("particle_render_pipeline".into()),
             vertex: VertexState {
                 shader: PARTICLE_SHADER_HANDLE.typed::<Shader>(),
                 entry_point: "vs_main".into(),
                 buffers: vec![],
-                shader_defs: vec![],
+                shader_defs: shader_defs.clone(),
             },
             fragment: Some(FragmentState {
                 shader: PARTICLE_SHADER_HANDLE.typed::<Shader>(),
-                shader_defs: vec![],
+                shader_defs,
                 entry_point: "fs_main".into(),
                 targets: vec![ColorTargetState {
                     format: TextureFormat::bevy_default(),
@@ -554,14 +543,10 @@ fn queue_particle_bind_groups(
                     entries: &[
                         BindGroupEntry {
                             binding: 0,
-                            resource: gpu_material.buffer.as_entire_binding(),
-                        },
-                        BindGroupEntry {
-                            binding: 1,
                             resource: BindingResource::TextureView(base_color_texture_view),
                         },
                         BindGroupEntry {
-                            binding: 2,
+                            binding: 1,
                             resource: BindingResource::Sampler(base_color_sampler),
                         },
                     ],
@@ -581,14 +566,18 @@ fn queue_particles(
     mut views_3d: Query<&mut RenderPhase<Transparent3d>>,
     mut pipelines: ResMut<SpecializedPipelines<ParticlePipeline>>,
     mut pipeline_cache: ResMut<RenderPipelineCache>,
-    particle_batches: Query<Entity, With<ParticleBatch>>,
+    particle_batches: Query<(Entity, &ParticleBatch)>,
     particle_pipeline: Res<ParticlePipeline>,
+    render_materials: Res<RenderAssets<ParticleMaterial>>,
 ) {
     let draw_2d = draw_functions_2d.read().get_id::<DrawParticle>().unwrap();
     let draw_3d = draw_functions_3d.read().get_id::<DrawParticle>().unwrap();
-    for entity in particle_batches.iter() {
+    for (entity, batch) in particle_batches.iter() {
+        let material = render_materials
+            .get(&batch.handle)
+            .expect("Failed to get ParticleMaterial PreparedAsset");
         let pipeline =
-            pipelines.specialize(&mut pipeline_cache, &particle_pipeline, ParticlePipelineKey);
+            pipelines.specialize(&mut pipeline_cache, &particle_pipeline, material.flags);
         for mut phase in views_2d.iter_mut() {
             phase.add(Transparent2d {
                 // TODO(james7132): properly compute this

From ce726836af1169acb630ab04147ac778009c4661 Mon Sep 17 00:00:00 2001
From: James Liu <contact@jamessliu.com>
Date: Wed, 5 Jan 2022 16:56:50 -0500
Subject: [PATCH 11/11] Support storage buffer-less platforms (like WebGL2)

---
 crates/bevy_particles/Cargo.toml        |   6 +-
 crates/bevy_particles/src/particle.wgsl |  24 +++-
 crates/bevy_particles/src/render.rs     | 146 ++++++++++++++++++------
 3 files changed, 138 insertions(+), 38 deletions(-)

diff --git a/crates/bevy_particles/Cargo.toml b/crates/bevy_particles/Cargo.toml
index a15da42020e12..51a99446f6931 100644
--- a/crates/bevy_particles/Cargo.toml
+++ b/crates/bevy_particles/Cargo.toml
@@ -23,4 +23,8 @@ bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0" }
 bevy_render = { path = "../bevy_render", version = "0.5.0" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
\ No newline at end of file
+bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
+
+[features]
+default = []
+webgl2 = []
\ No newline at end of file
diff --git a/crates/bevy_particles/src/particle.wgsl b/crates/bevy_particles/src/particle.wgsl
index 51e733703d198..aa8e052d69961 100644
--- a/crates/bevy_particles/src/particle.wgsl
+++ b/crates/bevy_particles/src/particle.wgsl
@@ -6,6 +6,12 @@ struct View {
 [[group(0), binding(0)]]
 var<uniform> view: View;
 
+#ifdef WEBGL2
+[[group(1), binding(0)]]
+var base_color_texture: texture_2d<f32>;
+[[group(1), binding(1)]]
+var base_color_sampler: sampler;
+#else
 struct PositionBuffer { data: array<vec4<f32>>; };
 struct SizeBuffer { data: array<f32>; };
 struct ColorBuffer { data: array<vec4<f32>>; };
@@ -16,13 +22,21 @@ var<storage, read> positions: PositionBuffer;
 var<storage, read> sizes: SizeBuffer;
 [[group(1), binding(2)]]
 var<storage, read> colors:ColorBuffer;
+
 [[group(2), binding(0)]]
 var base_color_texture: texture_2d<f32>;
 [[group(2), binding(1)]]
 var base_color_sampler: sampler;
+#endif
+
 
 struct VertexInput {
   [[builtin(vertex_index)]] vertex_idx: u32;
+#ifdef WEBGL2
+  [[location(0)]] position: vec4<f32>;
+  [[location(1)]] size: f32;
+  [[location(2)]] color: vec4<f32>;
+#endif
 };
 
 struct VertexOutput {
@@ -54,9 +68,17 @@ fn vs_main(model: VertexInput) -> VertexOutput {
   let camera_up = 
     normalize(vec3<f32>(view.view_proj.x.y, view.view_proj.y.y, view.view_proj.z.y));
 
+#ifdef WEBGL2
+  let particle_position = model.position.xyz;
+  let theta = model.position.w;
+  let size = model.size;
+  let color = model.color;
+#else
   let particle_position = positions.data[particle_idx].xyz;
   let theta = positions.data[particle_idx].w;
   let size = sizes.data[particle_idx];
+  let color = colors.data[particle_idx];
+#endif
   let sin_cos = vec2<f32>(cos(theta), sin(theta));
   
   let rotation = mat2x2<f32>(
@@ -73,7 +95,7 @@ fn vs_main(model: VertexInput) -> VertexOutput {
 
   var out: VertexOutput;
   out.position = view.view_proj * vec4<f32>(world_space, 1.0);
-  out.color = colors.data[particle_idx];
+  out.color = color;
   out.uv = uv;
   return out;
 }
diff --git a/crates/bevy_particles/src/render.rs b/crates/bevy_particles/src/render.rs
index c580a2224dc9b..7c888ac80113d 100644
--- a/crates/bevy_particles/src/render.rs
+++ b/crates/bevy_particles/src/render.rs
@@ -33,6 +33,7 @@ use wgpu::{
 
 pub const PARTICLE_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3032357527543835453);
+const QUAD_VERTEX_COUNT: u32 = 6;
 
 pub(crate) struct ParticleRenderPlugin;
 
@@ -79,6 +80,7 @@ impl Plugin for ParticleRenderPlugin {
 
 struct ParticlePipeline {
     view_layout: BindGroupLayout,
+    #[cfg(not(feature = "webgl2"))]
     particle_layout: BindGroupLayout,
     material_layout: BindGroupLayout,
 
@@ -104,6 +106,7 @@ impl FromWorld for ParticlePipeline {
             label: None,
         });
 
+        #[cfg(not(feature = "webgl2"))]
         let particle_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             label: None,
             entries: &[
@@ -211,6 +214,7 @@ impl FromWorld for ParticlePipeline {
 
         Self {
             view_layout,
+            #[cfg(not(feature = "webgl2"))]
             particle_layout,
             material_layout,
 
@@ -223,16 +227,29 @@ impl SpecializedPipeline for ParticlePipeline {
     type Key = ParticleMaterialFlags;
 
     fn specialize(&self, flags: Self::Key) -> RenderPipelineDescriptor {
+        #[cfg(feature = "webgl2")]
+        let mut shader_defs = vec!["WEBGL2".into()];
+        #[cfg(not(feature = "webgl2"))]
         let mut shader_defs = Vec::new();
         if flags.contains(ParticleMaterialFlags::BASE_COLOR_TEXTURE) {
             shader_defs.push("BASE_COLOR_TEXTURE".into());
         }
+
+        #[cfg(feature = "webgl2")]
+        let vertex_buffers = vec![
+            vertex_buffer_layout::<Vec4>(0, VertexFormat::Float32x4), // Position
+            vertex_buffer_layout::<f32>(1, VertexFormat::Float32),    // Size
+            vertex_buffer_layout::<Vec4>(2, VertexFormat::Float32x4), // Color
+        ];
+        #[cfg(not(feature = "webgl2"))]
+        let vertex_buffers = Vec::new();
+
         RenderPipelineDescriptor {
             label: Some("particle_render_pipeline".into()),
             vertex: VertexState {
                 shader: PARTICLE_SHADER_HANDLE.typed::<Shader>(),
                 entry_point: "vs_main".into(),
-                buffers: vec![],
+                buffers: vertex_buffers,
                 shader_defs: shader_defs.clone(),
             },
             fragment: Some(FragmentState {
@@ -274,6 +291,7 @@ impl SpecializedPipeline for ParticlePipeline {
             }),
             layout: Some(vec![
                 self.view_layout.clone(),
+                #[cfg(not(feature = "webgl2"))]
                 self.particle_layout.clone(),
                 self.material_layout.clone(),
             ]),
@@ -350,6 +368,7 @@ fn extract_particles(
 struct ParticleMeta {
     total_count: u64,
     view_bind_group: Option<BindGroup>,
+    #[cfg(not(feature = "webgl2"))]
     particle_bind_group: Option<BindGroup>,
 
     positions: BufferVec<Vec4>,
@@ -359,14 +378,28 @@ struct ParticleMeta {
 
 impl Default for ParticleMeta {
     fn default() -> Self {
-        ParticleMeta {
-            total_count: 0,
-            view_bind_group: None,
-            particle_bind_group: None,
-
-            positions: BufferVec::new(BufferUsages::STORAGE),
-            sizes: BufferVec::new(BufferUsages::STORAGE),
-            colors: BufferVec::new(BufferUsages::STORAGE),
+        #[cfg(feature = "webgl2")]
+        {
+            ParticleMeta {
+                total_count: 0,
+                view_bind_group: None,
+
+                positions: BufferVec::new(BufferUsages::VERTEX),
+                sizes: BufferVec::new(BufferUsages::VERTEX),
+                colors: BufferVec::new(BufferUsages::VERTEX),
+            }
+        }
+        #[cfg(not(feature = "webgl2"))]
+        {
+            ParticleMeta {
+                total_count: 0,
+                view_bind_group: None,
+                particle_bind_group: None,
+
+                positions: BufferVec::new(BufferUsages::STORAGE),
+                sizes: BufferVec::new(BufferUsages::STORAGE),
+                colors: BufferVec::new(BufferUsages::STORAGE),
+            }
         }
     }
 }
@@ -434,10 +467,33 @@ fn prepare_particles(
 
 fn batch_copy<T: Pod>(src: &[T], dst: &mut BufferVec<T>) {
     for item in src.iter() {
-        dst.push(*item);
+        #[cfg(not(feature = "webgl2"))]
+        {
+            dst.push(*item);
+        }
+        #[cfg(feature = "webgl2")]
+        {
+            for _ in 0..QUAD_VERTEX_COUNT {
+                dst.push(*item);
+            }
+        }
+    }
+}
+
+#[cfg(feature = "webgl2")]
+fn vertex_buffer_layout<T: Pod>(shader_location: u32, format: VertexFormat) -> VertexBufferLayout {
+    VertexBufferLayout {
+        array_stride: std::mem::size_of::<T>() as u64,
+        step_mode: VertexStepMode::Vertex,
+        attributes: vec![VertexAttribute {
+            format,
+            offset: 0,
+            shader_location,
+        }],
     }
 }
 
+#[cfg(not(feature = "webgl2"))]
 fn bind_buffer<T: Pod>(buffer: &BufferVec<T>, count: u64) -> BindingResource {
     BindingResource::Buffer(BufferBinding {
         buffer: buffer.buffer().expect("missing buffer"),
@@ -505,25 +561,28 @@ fn queue_particle_bind_groups(
     }
 
     // TODO(james7132): Find a way to cache this.
-    particle_meta.particle_bind_group =
-        Some(render_device.create_bind_group(&BindGroupDescriptor {
-            entries: &[
-                BindGroupEntry {
-                    binding: 0,
-                    resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 1,
-                    resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
-                },
-                BindGroupEntry {
-                    binding: 2,
-                    resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
-                },
-            ],
-            label: Some("particle_particle_bind_group"),
-            layout: &particle_pipeline.particle_layout,
-        }));
+    #[cfg(not(feature = "webgl2"))]
+    {
+        particle_meta.particle_bind_group =
+            Some(render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[
+                    BindGroupEntry {
+                        binding: 0,
+                        resource: bind_buffer(&particle_meta.positions, particle_meta.total_count),
+                    },
+                    BindGroupEntry {
+                        binding: 1,
+                        resource: bind_buffer(&particle_meta.sizes, particle_meta.total_count),
+                    },
+                    BindGroupEntry {
+                        binding: 2,
+                        resource: bind_buffer(&particle_meta.colors, particle_meta.total_count),
+                    },
+                ],
+                label: Some("particle_particle_bind_group"),
+                layout: &particle_pipeline.particle_layout,
+            }));
+    }
 
     for batch in particle_batches.iter() {
         let gpu_material = render_materials
@@ -633,7 +692,8 @@ impl DrawParticle {
         let batch = batches.get(entity).unwrap();
 
         if let Some(pipeline) = pipelines.into_inner().get(pipeline) {
-            let vertex_range = (batch.range.start * 6)..(batch.range.end * 6);
+            let vertex_range =
+                (batch.range.start * QUAD_VERTEX_COUNT)..(batch.range.end * QUAD_VERTEX_COUNT);
 
             pass.set_render_pipeline(pipeline);
             pass.set_bind_group(
@@ -641,12 +701,26 @@ impl DrawParticle {
                 particle_meta.view_bind_group.as_ref().unwrap(),
                 &[view_uniform.offset],
             );
-            pass.set_bind_group(1, particle_meta.particle_bind_group.as_ref().unwrap(), &[]);
-            pass.set_bind_group(
-                2,
-                material_bind_groups.values.get(&batch.handle).unwrap(),
-                &[],
-            );
+            #[cfg(feature = "webgl2")]
+            {
+                pass.set_vertex_buffer(0, particle_meta.positions.buffer().unwrap().slice(..));
+                pass.set_vertex_buffer(1, particle_meta.sizes.buffer().unwrap().slice(..));
+                pass.set_vertex_buffer(2, particle_meta.colors.buffer().unwrap().slice(..));
+                pass.set_bind_group(
+                    1,
+                    material_bind_groups.values.get(&batch.handle).unwrap(),
+                    &[],
+                );
+            }
+            #[cfg(not(feature = "webgl2"))]
+            {
+                pass.set_bind_group(1, particle_meta.particle_bind_group.as_ref().unwrap(), &[]);
+                pass.set_bind_group(
+                    2,
+                    material_bind_groups.values.get(&batch.handle).unwrap(),
+                    &[],
+                );
+            }
             pass.draw(vertex_range, 0..1);
         }
     }