GPU picking

Cargo.toml

@@ -670,6 +670,17 @@ description = "An application that runs with default plugins and displays an emp
 category = "Application"
 wasm = false
 
+[[example]]
+name = "picking"
+path = "examples/app/picking.rs"
+
+[package.metadata.example.picking]
+name = "Picking"
+description = "An application that show how to pick/select objects and UI elements"
+category = "Application"
+# TODO, are we wasm compatible?
+wasm = false
+
 [[example]]
 name = "without_winit"
 path = "examples/app/without_winit.rs"

crates/bevy_core_pipeline/Cargo.toml

@@ -31,3 +31,4 @@ bevy_utils = { path = "../bevy_utils", version = "0.9.0" }
 serde = { version = "1", features = ["derive"] }
 bitflags = "1.2"
 radsort = "0.1"
+bytemuck = { version = "1.5", features = ["derive"] }

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -5,6 +5,7 @@ use crate::{
 use bevy_ecs::prelude::*;
 use bevy_render::{
  camera::ExtractedCamera,
+ picking::PickingTextures,
  render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
  render_phase::RenderPhase,
  render_resource::{LoadOp, Operations, RenderPassDescriptor},
@@ -21,6 +22,7 @@ pub struct MainPass2dNode {
  &'static RenderPhase<Transparent2d>,
  &'static ViewTarget,
  &'static Camera2d,
+ Option<&'static PickingTextures>,
  ),
  With<ExtractedView>,
  >,
@@ -52,7 +54,7 @@ impl Node for MainPass2dNode {
  world: &World,
  ) -> Result<(), NodeRunError> {
  let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
- let (camera, transparent_phase, target, camera_2d) =
+ let (camera, transparent_phase, target, camera_2d, picking_textures) =
  if let Ok(result) = self.query.get_manual(world, view_entity) {
  result
  } else {
@@ -63,18 +65,27 @@ impl Node for MainPass2dNode {
  #[cfg(feature = "trace")]
  let _main_pass_2d = info_span!("main_pass_2d").entered();
 
+ let mut color_attachments = vec![Some(target.get_color_attachment(Operations {
+ load: match camera_2d.clear_color {
+ ClearColorConfig::Default => {
+ LoadOp::Clear(world.resource::<ClearColor>().0.into())
+ }
+ ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
+ ClearColorConfig::None => LoadOp::Load,
+ },
+ store: true,
+ }))];
+
+ if let Some(picking_textures) = picking_textures {
+ color_attachments.push(Some(picking_textures.get_color_attachment(Operations {
+ load: LoadOp::Clear(PickingTextures::clear_color()),
+ store: true,
+ })));
+ }
+
  let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
  label: Some("main_pass_2d"),
- color_attachments: &[Some(target.get_color_attachment(Operations {
- load: match camera_2d.clear_color {
- ClearColorConfig::Default => {
- LoadOp::Clear(world.resource::<ClearColor>().0.into())
- }
- ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
- ClearColorConfig::None => LoadOp::Load,
- },
- store: true,
- }))],
+ color_attachments: &color_attachments,
  depth_stencil_attachment: None,
  });
 

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -11,6 +11,7 @@ pub mod graph {
  pub const BLOOM: &str = "bloom";
  pub const TONEMAPPING: &str = "tonemapping";
  pub const FXAA: &str = "fxaa";
+ pub const PICKING: &str = "picking";
  pub const UPSCALING: &str = "upscaling";
  pub const END_MAIN_PASS_POST_PROCESSING: &str = "end_main_pass_post_processing";
  }
@@ -35,7 +36,7 @@ use bevy_render::{
 use bevy_utils::FloatOrd;
 use std::ops::Range;
 
-use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
+use crate::{picking::node::PickingNode, tonemapping::TonemappingNode, upscaling::UpscalingNode};
 
 pub struct Core2dPlugin;
 
@@ -61,13 +62,16 @@ impl Plugin for Core2dPlugin {
  let pass_node_2d = MainPass2dNode::new(&mut render_app.world);
  let tonemapping = TonemappingNode::new(&mut render_app.world);
  let upscaling = UpscalingNode::new(&mut render_app.world);
+ let picking = PickingNode::new(&mut render_app.world);
+
  let mut graph = render_app.world.resource_mut::<RenderGraph>();
 
  let mut draw_2d_graph = RenderGraph::default();
  draw_2d_graph.add_node(graph::node::MAIN_PASS, pass_node_2d);
  draw_2d_graph.add_node(graph::node::TONEMAPPING, tonemapping);
  draw_2d_graph.add_node(graph::node::END_MAIN_PASS_POST_PROCESSING, EmptyNode);
  draw_2d_graph.add_node(graph::node::UPSCALING, upscaling);
+ draw_2d_graph.add_node(graph::node::PICKING, picking);
  let input_node_id = draw_2d_graph.set_input(vec![SlotInfo::new(
  graph::input::VIEW_ENTITY,
  SlotType::Entity,
@@ -90,6 +94,12 @@ impl Plugin for Core2dPlugin {
  graph::node::UPSCALING,
  UpscalingNode::IN_VIEW,
  );
+ draw_2d_graph.add_slot_edge(
+ input_node_id,
+ graph::input::VIEW_ENTITY,
+ graph::node::PICKING,
+ PickingNode::IN_VIEW,
+ );
  draw_2d_graph.add_node_edge(graph::node::MAIN_PASS, graph::node::TONEMAPPING);
  draw_2d_graph.add_node_edge(
  graph::node::TONEMAPPING,
@@ -99,6 +109,7 @@ impl Plugin for Core2dPlugin {
  graph::node::END_MAIN_PASS_POST_PROCESSING,
  graph::node::UPSCALING,
  );
+ draw_2d_graph.add_node_edge(graph::node::UPSCALING, graph::node::PICKING);
  graph.add_sub_graph(graph::NAME, draw_2d_graph);
  }
 }

crates/bevy_core_pipeline/src/core_3d/main_pass_3d_node.rs

@@ -5,6 +5,7 @@ use crate::{
 use bevy_ecs::prelude::*;
 use bevy_render::{
  camera::ExtractedCamera,
+ picking::PickingTextures,
  render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
  render_phase::RenderPhase,
  render_resource::{LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor},
@@ -24,6 +25,7 @@ pub struct MainPass3dNode {
  &'static Camera3d,
  &'static ViewTarget,
  &'static ViewDepthTexture,
+ Option<&'static PickingTextures>,
  ),
  With<ExtractedView>,
  >,
@@ -55,13 +57,21 @@ impl Node for MainPass3dNode {
  world: &World,
  ) -> Result<(), NodeRunError> {
  let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
- let (camera, opaque_phase, alpha_mask_phase, transparent_phase, camera_3d, target, depth) =
- match self.query.get_manual(world, view_entity) {
- Ok(query) => query,
- Err(_) => {
- return Ok(());
- } // No window
- };
+ let (
+ camera,
+ opaque_phase,
+ alpha_mask_phase,
+ transparent_phase,
+ camera_3d,
+ target,
+ depth,
+ picking_textures,
+ ) = match self.query.get_manual(world, view_entity) {
+ Ok(query) => query,
+ Err(_) => {
+ return Ok(());
+ } // No window
+ };
 
  // Always run opaque pass to ensure screen is cleared
  {
@@ -70,20 +80,34 @@ impl Node for MainPass3dNode {
  #[cfg(feature = "trace")]
  let _main_opaque_pass_3d_span = info_span!("main_opaque_pass_3d").entered();
 
- let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
- label: Some("main_opaque_pass_3d"),
- // NOTE: The opaque pass loads the color
- // buffer as well as writing to it.
- color_attachments: &[Some(target.get_color_attachment(Operations {
+ let mut color_attachments = vec![Some(target.get_color_attachment(Operations {
+ load: match camera_3d.clear_color {
+ ClearColorConfig::Default => {
+ LoadOp::Clear(world.resource::<ClearColor>().0.into())
+ }
+ ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
+ ClearColorConfig::None => LoadOp::Load,
+ },
+ store: true,
+ }))];
+
+ if let Some(picking_textures) = picking_textures {
+ color_attachments.push(Some(picking_textures.get_color_attachment(Operations {
+ // If the wish is to not clear the screen, don't clear the picking buffer either.
+ // This may happen in situations such as a split screen game.
  load: match camera_3d.clear_color {
- ClearColorConfig::Default => {
- LoadOp::Clear(world.resource::<ClearColor>().0.into())
- }
- ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
  ClearColorConfig::None => LoadOp::Load,
+ _ => LoadOp::Clear(PickingTextures::clear_color()),
  },
  store: true,
- }))],
+ })));
+ }
+
+ let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
+ label: Some("main_opaque_pass_3d"),
+ // NOTE: The opaque pass loads the color
+ // buffer as well as writing to it.
+ color_attachments: &color_attachments,
  depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
  view: &depth.view,
  // NOTE: The opaque main pass loads the depth buffer and possibly overwrites it
@@ -109,13 +133,19 @@ impl Node for MainPass3dNode {
  #[cfg(feature = "trace")]
  let _main_alpha_mask_pass_3d_span = info_span!("main_alpha_mask_pass_3d").entered();
 
+ let operations = Operations {
+ load: LoadOp::Load,
+ store: true,
+ };
+ let mut color_attachments = vec![Some(target.get_color_attachment(operations))];
+ if let Some(picking_textures) = picking_textures {
+ color_attachments.push(Some(picking_textures.get_color_attachment(operations)));
+ }
+
  let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
  label: Some("main_alpha_mask_pass_3d"),
  // NOTE: The alpha_mask pass loads the color buffer as well as overwriting it where appropriate.
- color_attachments: &[Some(target.get_color_attachment(Operations {
- load: LoadOp::Load,
- store: true,
- }))],
+ color_attachments: &color_attachments,
  depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
  view: &depth.view,
  // NOTE: The alpha mask pass loads the depth buffer and possibly overwrites it
@@ -140,13 +170,19 @@ impl Node for MainPass3dNode {
  #[cfg(feature = "trace")]
  let _main_transparent_pass_3d_span = info_span!("main_transparent_pass_3d").entered();
 
+ let operations = Operations {
+ load: LoadOp::Load,
+ store: true,
+ };
+ let mut color_attachments = vec![Some(target.get_color_attachment(operations))];
+ if let Some(picking_textures) = picking_textures {
+ color_attachments.push(Some(picking_textures.get_color_attachment(operations)));
+ }
+
  let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
  label: Some("main_transparent_pass_3d"),
  // NOTE: The transparent pass loads the color buffer as well as overwriting it where appropriate.
- color_attachments: &[Some(target.get_color_attachment(Operations {
- load: LoadOp::Load,
- store: true,
- }))],
+ color_attachments: &color_attachments,
  depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
  view: &depth.view,
  // NOTE: For the transparent pass we load the depth buffer. There should be no

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -11,6 +11,7 @@ pub mod graph {
  pub const BLOOM: &str = "bloom";
  pub const TONEMAPPING: &str = "tonemapping";
  pub const FXAA: &str = "fxaa";
+ pub const PICKING: &str = "picking";
  pub const UPSCALING: &str = "upscaling";
  pub const END_MAIN_PASS_POST_PROCESSING: &str = "end_main_pass_post_processing";
  }
@@ -43,7 +44,7 @@ use bevy_render::{
 };
 use bevy_utils::{FloatOrd, HashMap};
 
-use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
+use crate::{picking::node::PickingNode, tonemapping::TonemappingNode, upscaling::UpscalingNode};
 
 pub struct Core3dPlugin;
 
@@ -71,13 +72,16 @@ impl Plugin for Core3dPlugin {
  let pass_node_3d = MainPass3dNode::new(&mut render_app.world);
  let tonemapping = TonemappingNode::new(&mut render_app.world);
  let upscaling = UpscalingNode::new(&mut render_app.world);
+ let picking = PickingNode::new(&mut render_app.world);
+
  let mut graph = render_app.world.resource_mut::<RenderGraph>();
 
  let mut draw_3d_graph = RenderGraph::default();
  draw_3d_graph.add_node(graph::node::MAIN_PASS, pass_node_3d);
  draw_3d_graph.add_node(graph::node::TONEMAPPING, tonemapping);
  draw_3d_graph.add_node(graph::node::END_MAIN_PASS_POST_PROCESSING, EmptyNode);
  draw_3d_graph.add_node(graph::node::UPSCALING, upscaling);
+ draw_3d_graph.add_node(graph::node::PICKING, picking);
  let input_node_id = draw_3d_graph.set_input(vec![SlotInfo::new(
  graph::input::VIEW_ENTITY,
  SlotType::Entity,
@@ -100,6 +104,12 @@ impl Plugin for Core3dPlugin {
  graph::node::UPSCALING,
  UpscalingNode::IN_VIEW,
  );
+ draw_3d_graph.add_slot_edge(
+ input_node_id,
+ graph::input::VIEW_ENTITY,
+ graph::node::PICKING,
+ PickingNode::IN_VIEW,
+ );
  draw_3d_graph.add_node_edge(graph::node::MAIN_PASS, graph::node::TONEMAPPING);
  draw_3d_graph.add_node_edge(
  graph::node::TONEMAPPING,
@@ -109,6 +119,7 @@ impl Plugin for Core3dPlugin {
  graph::node::END_MAIN_PASS_POST_PROCESSING,
  graph::node::UPSCALING,
  );
+ draw_3d_graph.add_node_edge(graph::node::UPSCALING, graph::node::PICKING);
  graph.add_sub_graph(graph::NAME, draw_3d_graph);
  }
 }
@@ -281,7 +292,7 @@ pub fn prepare_core_3d_depth_textures(
  dimension: TextureDimension::D2,
  format: TextureFormat::Depth32Float, /* PERF: vulkan docs recommend using 24
  * bit depth for better performance */
- usage: TextureUsages::RENDER_ATTACHMENT,
+ usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::COPY_SRC,
  },
  )
  })

crates/bevy_core_pipeline/src/lib.rs

@@ -4,6 +4,7 @@ pub mod core_2d;
 pub mod core_3d;
 pub mod fullscreen_vertex_shader;
 pub mod fxaa;
+pub mod picking;
 pub mod tonemapping;
 pub mod upscaling;
 
@@ -23,6 +24,7 @@ use crate::{
  core_3d::Core3dPlugin,
  fullscreen_vertex_shader::FULLSCREEN_SHADER_HANDLE,
  fxaa::FxaaPlugin,
+ picking::{PickingPlugin, PICKING_SHADER_HANDLE},
  tonemapping::TonemappingPlugin,
  upscaling::UpscalingPlugin,
 };
@@ -42,6 +44,13 @@ impl Plugin for CorePipelinePlugin {
  Shader::from_wgsl
  );
 
+ load_internal_asset!(
+ app,
+ PICKING_SHADER_HANDLE,
+ "picking/picking.wgsl",
+ Shader::from_wgsl
+ );
+
  app.register_type::<ClearColor>()
  .register_type::<ClearColorConfig>()
  .init_resource::<ClearColor>()
@@ -51,6 +60,7 @@ impl Plugin for CorePipelinePlugin {
  .add_plugin(TonemappingPlugin)
  .add_plugin(UpscalingPlugin)
  .add_plugin(BloomPlugin)
- .add_plugin(FxaaPlugin);
+ .add_plugin(FxaaPlugin)
+ .add_plugin(PickingPlugin);
  }
 }