Simplify code

Author: blaind

crates/bevy_gltf/src/loader.rs

@@ -475,7 +475,7 @@ fn load_node(
 
                 node.insert(Camera {
                     name: Some(base::camera::CAMERA_2D.to_owned()),
-                    projection_matrix: orthographic_projection.get_projection_matrix(),
+                    projection_matrices: vec![orthographic_projection.get_projection_matrix()],
                     ..Default::default()
                 });
                 node.insert(orthographic_projection);
@@ -497,10 +497,9 @@ fn load_node(
                 }
                 node.insert(Camera {
                     name: Some(base::camera::CAMERA_3D.to_owned()),
-                    projection_matrix: perspective_projection.get_projection_matrix(),
+                    projection_matrices: vec![perspective_projection.get_projection_matrix()],
                     ..Default::default()
                 });
-                // FIXME how to differentiate between CAMERA_XR and CAMERA_3D?
                 node.insert(perspective_projection);
             }
         }

crates/bevy_internal/Cargo.toml

@@ -18,7 +18,7 @@ wgpu_trace = ["bevy_wgpu/trace"]
 trace = [ "bevy_app/trace", "bevy_ecs/trace" ]
 trace_chrome = [ "bevy_log/tracing-chrome" ]
 
-use-openxr = ["bevy_wgpu/use-openxr", "bevy_render/use-openxr", "bevy_openxr", "bevy_openxr_core"]
+use-openxr = ["bevy_wgpu/use-openxr", "bevy_openxr", "bevy_openxr_core"]
 
 # Image format support for texture loading (PNG and HDR are enabled by default)
 hdr = ["bevy_render/hdr"]
@@ -74,7 +74,7 @@ bevy_openxr_core = { path = "../bevy_openxr_core", optional = true, version = "0
 bevy_sprite = { path = "../bevy_sprite", 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_wgpu = { path = "../bevy_wgpu", optional = true, version = "0.5.0" }
+bevy_wgpu = { path = "../bevy_wgpu", optional = true, default-features = false, version = "0.5.0" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
 bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.5.0" }
 

crates/bevy_openxr/Cargo.toml

@@ -23,11 +23,12 @@ bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_openxr_core = { path = "../bevy_openxr_core", version = "0.5.0" }
 bevy_pbr = { path = "../bevy_pbr", version = "0.5.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0" }
-bevy_render = { path = "../bevy_render", version = "0.5.0", features = ["use-openxr"] }
+bevy_render = { path = "../bevy_render", version = "0.5.0" }
 bevy_scene = { path = "../bevy_scene", version = "0.5.0" } # FIXME not really needed, except for plugin order
 bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 bevy_wgpu = { path = "../bevy_wgpu", version = "0.5.0", default-features = false, features = ["use-openxr"] }
+bevy_window = { path = "../bevy_window", version = "0.5.0" }
 
 # other
 openxr = { path = "../../../openxrs/openxr", features = ["loaded"], default-features = false }

crates/bevy_openxr/src/lib.rs

@@ -1,12 +1,18 @@
 use bevy_app::{
-    AppBuilder, Plugin, PluginGroupBuilder, ScheduleRunnerPlugin, ScheduleRunnerSettings,
+    AppBuilder, CoreStage, Plugin, PluginGroupBuilder, ScheduleRunnerPlugin, ScheduleRunnerSettings,
 };
 use bevy_ecs::prelude::*;
 use bevy_openxr_core::{
-    event::{XRViewSurfaceCreated, XRViewsCreated},
-    XrFovf,
+    event::{XRCameraTransformsUpdated, XRState, XRViewSurfaceCreated, XRViewsCreated},
+    math::XRMatrixComputation,
+    XRConfigurationState, XRDevice,
+};
+use bevy_render::{
+    camera::Camera,
+    camera::CameraProjection,
+    render_graph::{base::node, RenderGraph, WindowTextureNode},
+    RenderPlugin, RenderStage,
 };
-use bevy_render::{camera::Camera, camera::CameraProjection, RenderPlugin};
 
 pub mod prelude {
     pub use crate::{HandPoseEvent, OpenXRPlugin, OpenXRSettings};
@@ -16,12 +22,17 @@ pub mod prelude {
 
 use bevy_utils::tracing::warn;
 use bevy_wgpu::{WgpuBackend, WgpuOptions};
+use bevy_window::{CreateWindow, Window, WindowId, Windows};
 use openxr::HandJointLocations;
 
 mod error;
 mod hand_tracking;
 mod platform;
 mod projection;
+mod xr_swapchain_node;
+use xr_swapchain_node::XRSwapchainNode;
+mod xr_window_texture_node;
+use xr_window_texture_node::XRWindowTextureNode;
 
 pub use hand_tracking::*;
 pub use projection::*;
@@ -40,8 +51,7 @@ pub fn get_render_plugin() -> RenderPlugin {
     RenderPlugin {
         base_render_graph_config: Some(bevy_render::render_graph::base::BaseRenderGraphConfig {
             add_2d_camera: false,
-            add_3d_camera: false,
-            add_xr_camera: true,
+            add_3d_camera: true,
             ..Default::default()
         }),
     }
@@ -88,7 +98,7 @@ impl Plugin for OpenXRPlugin {
             ))
             .add_plugin(ScheduleRunnerPlugin::default())
             .add_event::<HandPoseEvent>()
-            .add_system(openxr_camera_system.system());
+            .add_system_to_stage(CoreStage::PostUpdate, openxr_camera_system.system());
     }
 }
 
@@ -112,23 +122,137 @@ fn openxr_camera_system(
     mut camera_query: Query<(&mut Camera, &mut XRProjection)>,
     mut view_surface_created_events: EventReader<XRViewSurfaceCreated>,
     mut views_created_events: EventReader<XRViewsCreated>,
+    mut camera_transforms_updated: EventReader<XRCameraTransformsUpdated>,
 ) {
+    // FIXME: remove
     for event in view_surface_created_events.iter() {
         for (_, mut camera_projection) in camera_query.iter_mut() {
             // this is actually unnecessary?
             camera_projection.update(event.width as f32, event.height as f32);
         }
     }
 
+    // initialize projection matrices on view creation
     for event in views_created_events.iter() {
         for (mut camera, camera_projection) in camera_query.iter_mut() {
-            camera.multiview_projection_matrices = event
+            camera.depth_calculation = camera_projection.depth_calculation();
+            camera.projection_matrices = event
                 .views
                 .iter()
                 .map(|view| camera_projection.get_projection_matrix_fov(&view.fov))
                 .collect::<Vec<_>>();
+        }
+    }
 
-            camera.depth_calculation = camera_projection.depth_calculation();
+    for event in camera_transforms_updated.iter() {
+        for (mut camera, _) in camera_query.iter_mut() {
+            camera.position_matrices = event
+                .transforms
+                .iter()
+                .map(|transform| transform.compute_xr_matrix())
+                .collect::<Vec<_>>();
+        }
+    }
+}
+
+pub struct OpenXRWgpuPlugin;
+
+impl Plugin for OpenXRWgpuPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_startup_system(add_xr_render_graph.system())
+            .add_system(handle_create_window_events.system())
+            .add_system_to_stage(
+                RenderStage::Draw,
+                pre_render_system.exclusive_system(), // FIXME there should maybe be some ImmediatelyBeforeRender system
+            )
+            .add_system_to_stage(
+                RenderStage::PostRender,
+                post_render_system.exclusive_system(), // FIXME there should maybe be some ImmediatelyAfterPost system
+            );
+    }
+}
+
+fn pre_render_system(
+    mut xr_device: ResMut<XRDevice>,
+    wgpu_handles: ResMut<bevy_wgpu::WgpuRendererHandles>,
+    mut wgpu_render_state: ResMut<bevy_wgpu::WgpuRenderState>,
+    mut xr_configuration_state: ResMut<XRConfigurationState>,
+) {
+    let (state, texture_views) = xr_device.prepare_update(&wgpu_handles.device);
+
+    let should_render = if let XRState::Running = state {
+        true
+    } else {
+        false
+    };
+
+    if let Some(texture_views) = texture_views {
+        xr_configuration_state.texture_views = Some(texture_views);
+    }
+
+    if should_render {
+        xr_configuration_state.next_swap_chain_index = xr_device
+            .get_swapchain_mut()
+            .unwrap()
+            .get_next_swapchain_image_index();
+    }
+
+    wgpu_render_state.should_render = should_render;
+}
+
+fn post_render_system(mut xr_device: ResMut<XRDevice>) {
+    xr_device.finalize_update();
+}
+
+fn add_xr_render_graph(mut graph: ResMut<RenderGraph>) {
+    let main_depth_texture: &WindowTextureNode = graph.get_node(node::MAIN_DEPTH_TEXTURE).unwrap();
+    let descriptor = *main_depth_texture.descriptor();
+
+    graph
+        .replace_node(
+            node::MAIN_DEPTH_TEXTURE,
+            XRWindowTextureNode::new(descriptor),
+        )
+        .unwrap();
+
+    graph
+        .replace_node(node::PRIMARY_SWAP_CHAIN, XRSwapchainNode::new())
+        .unwrap();
+
+    let main_sampled_color_attachment: &WindowTextureNode =
+        graph.get_node(node::MAIN_SAMPLED_COLOR_ATTACHMENT).unwrap();
+
+    let descriptor = *main_sampled_color_attachment.descriptor();
+
+    graph
+        .replace_node(
+            node::MAIN_SAMPLED_COLOR_ATTACHMENT,
+            XRWindowTextureNode::new(descriptor),
+        )
+        .unwrap();
+}
+
+fn handle_create_window_events(
+    mut windows: ResMut<Windows>,
+    mut create_window_events: EventReader<CreateWindow>,
+    // mut window_created_events: EventWriter<WindowCreated>,
+) {
+    for _create_window_event in create_window_events.iter() {
+        if let None = windows.get_primary() {
+            windows.add(Window::new(
+                WindowId::primary(),
+                &Default::default(),
+                896,
+                1008,
+                1.,
+                None,
+            ));
         }
+
+        /*
+        window_created_events.send(WindowCreated {
+            id: create_window_event.id,
+        });
+         */
     }
 }

crates/bevy_openxr/src/projection.rs

@@ -1,10 +1,12 @@
 use bevy_ecs::bundle::Bundle;
 use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Mat4;
-use bevy_openxr_core::XrFovf;
+use bevy_openxr_core::{View, XrFovf};
 use bevy_reflect::Reflect;
-use bevy_render::camera::{Camera, CameraProjection, DepthCalculation, VisibleEntities};
-use bevy_render::render_graph::base::camera::CAMERA_XR;
+use bevy_render::{
+    camera::{Camera, CameraProjection, DepthCalculation, VisibleEntities},
+    render_graph::base::camera::CAMERA_3D,
+};
 use bevy_transform::components::{GlobalTransform, Transform};
 
 #[derive(Debug, Clone, Reflect)]
@@ -145,7 +147,7 @@ impl Default for XRCameraBundle {
     fn default() -> Self {
         XRCameraBundle {
             camera: Camera {
-                name: Some(CAMERA_XR.to_string()),
+                name: Some(CAMERA_3D.to_string()),
                 ..Default::default()
             },
             // FIXME: ..Default::default() here causes stack overflow? Wut?

crates/bevy_openxr/src/xr_swapchain_node.rs

@@ -0,0 +1,94 @@
+use std::{any::Any, borrow::Cow};
+
+use bevy_ecs::world::World;
+use bevy_openxr_core::XRConfigurationState;
+
+use bevy_render::{
+    render_graph::{Node, ResourceSlotInfo, ResourceSlots},
+    renderer::{
+        RenderContext, RenderResourceContext, RenderResourceId, RenderResourceType, TextureId,
+    },
+};
+use bevy_wgpu::renderer::{WgpuRenderContext, WgpuRenderResourceContext};
+
+/// Like `WindowSwapChainNode`, but for XR implementation
+/// XR implementation initializes the underlying textures at the startup, and after that
+/// this node will swap the textures based on texture id retrieved from XR swapchain
+#[derive(Default)]
+pub struct XRSwapchainNode {
+    resource_ids: Option<Vec<(RenderResourceId, Option<wgpu::TextureView>)>>,
+}
+
+impl XRSwapchainNode {
+    pub const OUT_TEXTURE: &'static str = "texture";
+
+    pub fn new() -> Self {
+        XRSwapchainNode::default()
+    }
+}
+
+impl Node for XRSwapchainNode {
+    fn output(&self) -> &[ResourceSlotInfo] {
+        static OUTPUT: &[ResourceSlotInfo] = &[ResourceSlotInfo {
+            name: Cow::Borrowed(XRSwapchainNode::OUT_TEXTURE),
+            resource_type: RenderResourceType::Texture,
+        }];
+        OUTPUT
+    }
+
+    fn prepare(&mut self, world: &mut World) {
+        let mut xr_configuration_state = world.get_resource_mut::<XRConfigurationState>().unwrap();
+        if let None = self.resource_ids {
+            // move array of textures from the swapchain into render resource context
+            // and set textures to this node
+            self.resource_ids = Some(
+                xr_configuration_state
+                    .texture_views
+                    .take()
+                    .unwrap()
+                    .into_iter()
+                    .map(|texture_view| {
+                        (
+                            RenderResourceId::Texture(TextureId::new()),
+                            Some(texture_view),
+                        )
+                    })
+                    .collect(),
+            );
+        }
+    }
+
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        output: &mut ResourceSlots,
+    ) {
+        const WINDOW_TEXTURE: usize = 0;
+        let xr_configuration_state = world.get_resource::<XRConfigurationState>().unwrap();
+
+        // get next texture by id
+        let render_resource_id = self
+            .resource_ids
+            .as_mut()
+            .unwrap()
+            .get_mut(xr_configuration_state.next_swap_chain_index)
+            .unwrap();
+
+        if let Some(texture_view) = render_resource_id.1.take() {
+            if let RenderResourceId::Texture(texture_id) = render_resource_id.0 {
+                let render_resource_context = render_context.resources_mut();
+
+                let render_resource_context = render_resource_context
+                    .downcast_mut::<WgpuRenderResourceContext>()
+                    .unwrap();
+
+                render_resource_context.add_wgpu_texture_view(texture_id, texture_view);
+            }
+        }
+
+        // set output to desired resource id
+        output.set(WINDOW_TEXTURE, render_resource_id.0.clone());
+    }
+}

crates/bevy_render/src/render_graph/nodes/xr_window_texture_node.rs renamed to crates/bevy_openxr/src/xr_window_texture_node.rs

@@ -1,11 +1,11 @@
-use crate::{
+use bevy_app::{Events, ManualEventReader};
+use bevy_ecs::world::World;
+use bevy_openxr_core::event::XRViewSurfaceCreated;
+use bevy_render::{
     render_graph::{Node, ResourceSlotInfo, ResourceSlots, WindowTextureNode},
     renderer::{RenderContext, RenderResourceId, RenderResourceType},
     texture::TextureDescriptor,
 };
-use bevy_app::{Events, ManualEventReader};
-use bevy_ecs::world::World;
-use bevy_openxr_core::event::XRViewSurfaceCreated;
 use std::borrow::Cow;
 
 /// MAIN_SAMPLED_COLOR_ATTACHMENT node in OpenXR implementation, used instead of `WindowTextureNode`
@@ -35,7 +35,7 @@ impl Node for XRWindowTextureNode {
 
     fn update(
         &mut self,
-        world: &mut World,
+        world: &World,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         output: &mut ResourceSlots,