Add polylines and spheres for handling large worlds

rmf_site_editor/Cargo.toml

@@ -19,7 +19,7 @@ path = "examples/extending_menu.rs"
 bevy_egui = "0.19"
 bevy_mod_picking = "0.11"
 bevy_mod_raycast = "0.7"
-bevy_mod_outline = "0.3.3"
+bevy_mod_outline = { git = "https://github.com/arjo129/bevy_mod_outline.git", branch= "09_compatibility"}
 bevy_infinite_grid = "0.6"
 bevy_polyline = "0.4"
 bevy_stl = "0.7.0"
@@ -49,6 +49,12 @@ rfd = "0.11"
 urdf-rs = "0.7"
 utm = "0.1.6"
 sdformat_rs = { git = "https://github.com/open-rmf/sdf_rust_experimental", rev = "f86344f"}
+pollster = "0.3.0"
+futures-intrusive = "0.5.0"
+wgpu="0.14.2"
+image = "0.24.6"
+rand = "0.8.5"
+bevy_points = "0.1.3"
 gz-fuel = { git = "https://github.com/open-rmf/gz-fuel-rs", branch = "first_implementation" }
 pathdiff = "*"
 

rmf_site_editor/src/interaction/anchor.rs

@@ -20,7 +20,7 @@ use crate::{
     interaction::IntersectGroundPlaneParams,
     interaction::*,
     keyboard::DebugMode,
-    site::{Anchor, Category, Delete, Dependents, SiteAssets, Subordinate},
+    site::{Anchor, Category, Delete, Dependents, PointAsset, SiteAssets, Subordinate},
 };
 use bevy::prelude::*;
 
@@ -38,6 +38,8 @@ pub fn add_anchor_visual_cues(
     >,
     categories: Query<&Category>,
     site_assets: Res<SiteAssets>,
+    point_assets: Res<PointAsset>,
+    interaction_assets: Res<InteractionAssets>,
 ) {
     for (e, parent, subordinate, anchor) in &new_anchors {
         let body_mesh = match categories.get(parent.get()).unwrap() {
@@ -47,13 +49,23 @@ pub fn add_anchor_visual_cues(
         };
 
         let mut entity_commands = commands.entity(e);
+        entity_commands.insert(LimitScaleFactor {
+            distance_to_start_scaling: 10.0,
+            original_scale: 1.0,
+        });
         let body = entity_commands.add_children(|parent| {
             let mut body = parent.spawn(PbrBundle {
                 mesh: body_mesh,
                 material: site_assets.passive_anchor_material.clone(),
                 ..default()
             });
             body.insert(Selectable::new(e));
+            body.insert(MaterialMeshBundle {
+                mesh: point_assets.bevy_point_mesh.clone(),
+                material: point_assets.bevy_point_material.clone(),
+                ..default()
+            });
+            body.insert(ScreenSpaceSelection::Point(e));
             if subordinate.is_none() {
                 body.insert(DragPlaneBundle::new(e, Vec3::Z));
             }

rmf_site_editor/src/interaction/camera_controls.rs

@@ -49,13 +49,19 @@ pub const HOVERED_OUTLINE_LAYER: u8 = 4;
 /// The X-Ray layer is used to show visual cues that need to be rendered
 /// above anything that would be obstructing them.
 pub const XRAY_RENDER_LAYER: u8 = 5;
+/// The Line Picking layer contains an entity based color map for picking
+/// polylines which are drawn in screen space.
+pub const LINE_PICKING_LAYER: u8 = 6;
+/// The Line Picking layer contains an entity based color map for picking
+/// points which are drawn in screen space.
+pub const POINT_PICKING_LAYER: u8 = 7;
 /// The Model Preview layer is used by model previews to spawn and render
 /// models in the engine without having them being visible to general cameras
-pub const MODEL_PREVIEW_LAYER: u8 = 6;
+pub const MODEL_PREVIEW_LAYER: u8 = 8;
 
 #[derive(Resource)]
-struct MouseLocation {
-    previous: Vec2,
+pub struct MouseLocation {
+    pub previous: Vec2,
 }
 
 impl Default for MouseLocation {

rmf_site_editor/src/interaction/color_based_picker/camera_capture.rs

@@ -0,0 +1,184 @@
+// Taken from https://github.com/bevyengine/bevy/pull/5550/files
+// Might be useful to move this to a utils folder.
+use std::sync::Arc;
+
+use bevy::prelude::*;
+use bevy::render::render_asset::RenderAssets;
+use bevy::render::render_graph::{self, NodeRunError, RenderGraph, RenderGraphContext};
+use bevy::render::renderer::{RenderContext, RenderDevice, RenderQueue};
+use bevy::render::{Extract, RenderApp, RenderStage};
+
+use bevy::render::render_resource::{
+    Buffer, BufferDescriptor, BufferUsages, CommandEncoderDescriptor, Extent3d, ImageCopyBuffer,
+    ImageDataLayout,
+};
+use pollster::FutureExt;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+pub fn receive_images(
+    image_copiers: Query<&ImageCopier>,
+    mut images: ResMut<Assets<Image>>,
+    render_device: Res<RenderDevice>,
+) {
+    for image_copier in image_copiers.iter() {
+        if !image_copier.enabled() {
+            continue;
+        }
+        // Derived from: https://sotrh.github.io/learn-wgpu/showcase/windowless/#a-triangle-without-a-window
+        // We need to scope the mapping variables so that we can
+        // unmap the buffer
+        async {
+            let buffer_slice = image_copier.buffer.slice(..);
+
+            // NOTE: We have to create the mapping THEN device.poll() before await
+            // the future. Otherwise the application will freeze.
+            let (tx, rx) = futures_intrusive::channel::shared::oneshot_channel();
+            buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
+                tx.send(result).unwrap();
+            });
+            render_device.poll(wgpu::Maintain::Wait);
+            rx.receive().await.unwrap().unwrap();
+            if let Some(mut image) = images.get_mut(&image_copier.dst_image) {
+                image.data = buffer_slice.get_mapped_range().to_vec();
+            }
+
+            image_copier.buffer.unmap();
+        }
+        .block_on();
+    }
+}
+
+pub const IMAGE_COPY: &str = "image_copy";
+
+pub struct ImageCopyPlugin;
+impl Plugin for ImageCopyPlugin {
+    fn build(&self, app: &mut App) {
+        let render_app = app.add_system(receive_images).sub_app_mut(RenderApp);
+
+        render_app.add_system_to_stage(RenderStage::Extract, image_copy_extract);
+
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+
+        graph.add_node(IMAGE_COPY, ImageCopyDriver::default());
+
+        graph
+            .add_node_edge(IMAGE_COPY, bevy::render::main_graph::node::CAMERA_DRIVER)
+            .unwrap();
+    }
+}
+
+#[derive(Clone, Default, Resource, Deref, DerefMut)]
+pub struct ImageCopiers(pub Vec<ImageCopier>);
+
+#[derive(Clone, Component)]
+pub struct ImageCopier {
+    buffer: Buffer,
+    enabled: Arc<AtomicBool>,
+    src_image: Handle<Image>,
+    dst_image: Handle<Image>,
+}
+
+impl ImageCopier {
+    pub fn new(
+        src_image: Handle<Image>,
+        dst_image: Handle<Image>,
+        size: Extent3d,
+        render_device: &RenderDevice,
+    ) -> ImageCopier {
+        let padded_bytes_per_row =
+            RenderDevice::align_copy_bytes_per_row((size.width) as usize) * 4;
+
+        let cpu_buffer = render_device.create_buffer(&BufferDescriptor {
+            label: None,
+            size: padded_bytes_per_row as u64 * size.height as u64,
+            usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        ImageCopier {
+            buffer: cpu_buffer,
+            src_image,
+            dst_image,
+            enabled: Arc::new(AtomicBool::new(true)),
+        }
+    }
+
+    pub fn enable(&self) {
+        self.enabled.store(true, Ordering::Relaxed);
+    }
+
+    pub fn disable(&self) {
+        self.enabled.store(false, Ordering::Relaxed);
+    }
+
+    pub fn enabled(&self) -> bool {
+        self.enabled.load(Ordering::Relaxed)
+    }
+}
+
+pub fn image_copy_extract(mut commands: Commands, image_copiers: Extract<Query<&ImageCopier>>) {
+    commands.insert_resource(ImageCopiers(
+        image_copiers.iter().cloned().collect::<Vec<ImageCopier>>(),
+    ));
+}
+
+#[derive(Default)]
+pub struct ImageCopyDriver;
+
+impl render_graph::Node for ImageCopyDriver {
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let image_copiers = world.get_resource::<ImageCopiers>().unwrap();
+        let gpu_images = world.get_resource::<RenderAssets<Image>>().unwrap();
+
+        for image_copier in image_copiers.iter() {
+            if !image_copier.enabled() {
+                continue;
+            }
+
+            let src_image = gpu_images.get(&image_copier.src_image).unwrap();
+
+            let mut encoder = render_context
+                .render_device
+                .create_command_encoder(&CommandEncoderDescriptor::default());
+
+            let format = src_image.texture_format.describe();
+
+            let padded_bytes_per_row = RenderDevice::align_copy_bytes_per_row(
+                (src_image.size.x as usize / format.block_dimensions.0 as usize)
+                    * format.block_size as usize,
+            );
+
+            let texture_extent = Extent3d {
+                width: src_image.size.x as u32,
+                height: src_image.size.y as u32,
+                depth_or_array_layers: 1,
+            };
+
+            encoder.copy_texture_to_buffer(
+                src_image.texture.as_image_copy(),
+                ImageCopyBuffer {
+                    buffer: &image_copier.buffer,
+                    layout: ImageDataLayout {
+                        offset: 0,
+                        bytes_per_row: Some(
+                            std::num::NonZeroU32::new(padded_bytes_per_row as u32).unwrap(),
+                        ),
+                        rows_per_image: None,
+                    },
+                },
+                texture_extent,
+            );
+
+            let render_queue = world.get_resource::<RenderQueue>().unwrap();
+            render_queue.submit(std::iter::once(encoder.finish()));
+        }
+
+        Ok(())
+    }
+}