allow disabling of pipelined rendering and disable one log in handtracking

examples/android/src/lib.rs

@@ -5,7 +5,6 @@ use bevy_oxr::graphics::extensions::XrExtensions;
 use bevy_oxr::graphics::XrAppInfo;
 use bevy_oxr::passthrough::{PausePassthrough, ResumePassthrough, XrPassthroughState};
 use bevy_oxr::xr_init::xr_only;
-use bevy_oxr::xr_input::debug_gizmos::OpenXrDebugRenderer;
 use bevy_oxr::xr_input::hands::common::HandInputDebugRenderer;
 use bevy_oxr::xr_input::hands::HandBone;
 use bevy_oxr::xr_input::prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig};
@@ -17,7 +16,7 @@ use bevy_oxr::DefaultXrPlugins;
 #[bevy_main]
 fn main() {
     let mut xr_extensions = XrExtensions::default();
-    // xr_extensions.enable_fb_passthrough();
+    xr_extensions.enable_fb_passthrough();
     xr_extensions.enable_hand_tracking();
     App::new()
         .add_plugins(DefaultXrPlugins {
@@ -25,13 +24,14 @@ fn main() {
             app_info: XrAppInfo {
                 name: "Bevy OXR Android Example".into(),
             },
-            prefered_blend_mode: bevy_oxr::graphics::XrPreferdBlendMode::Opaque,
+            enable_pipelined_rendering: false,
+            ..Default::default()
         })
         // .add_plugins(OpenXrDebugRenderer)
         .add_plugins(LogDiagnosticsPlugin::default())
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_plugins(HandInputDebugRenderer)
-        // .add_plugins(bevy_oxr::passthrough::EnablePassthroughStartup)
+        .add_plugins(bevy_oxr::passthrough::EnablePassthroughStartup)
         .add_systems(Startup, setup)
         .add_systems(
             Update,

examples/demo/src/lib.rs

@@ -76,10 +76,10 @@ pub fn main() {
         //lets get the xr defaults added
         .add_plugins(DefaultXrPlugins {
             reqeusted_extensions: xr_extensions,
-            prefered_blend_mode: XrPreferdBlendMode::Opaque,
             app_info: XrAppInfo {
                 name: "Bevy OXR Demo".into(),
             },
+            ..Default::default()
         })
         //lets add the debug renderer for the controllers
         .add_plugins(OpenXrDebugRenderer)

src/lib.rs

@@ -46,11 +46,11 @@ pub const LEFT_XR_TEXTURE_HANDLE: ManualTextureViewHandle = ManualTextureViewHan
 pub const RIGHT_XR_TEXTURE_HANDLE: ManualTextureViewHandle = ManualTextureViewHandle(3383858418);
 
 /// Adds OpenXR support to an App
-#[derive(Default)]
 pub struct OpenXrPlugin {
-    reqeusted_extensions: XrExtensions,
-    prefered_blend_mode: XrPreferdBlendMode,
-    app_info: XrAppInfo,
+    pub reqeusted_extensions: XrExtensions,
+    pub prefered_blend_mode: XrPreferdBlendMode,
+    pub app_info: XrAppInfo,
+    pub enable_pipelined_rendering: bool,
 }
 
 impl Plugin for OpenXrPlugin {
@@ -114,6 +114,9 @@ impl Plugin for OpenXrPlugin {
             app.add_plugins(RenderPlugin::default());
             app.insert_resource(XrStatus::Disabled);
         }
+        if self.enable_pipelined_rendering {
+            app.insert_resource(DoPipelinedRendering);
+        }
         app.add_systems(XrPostCleanup, clean_resources);
         app.add_systems(XrPostCleanup, || info!("Main World Post Cleanup!"));
         app.add_systems(
@@ -166,6 +169,9 @@ impl Plugin for OpenXrPlugin {
     }
 }
 
+#[derive(Resource)]
+struct DoPipelinedRendering;
+
 fn clean_resources_render(mut cmds: &mut World) {
     // let session = cmds.remove_resource::<XrSession>().unwrap();
     cmds.remove_resource::<XrSession>();
@@ -221,16 +227,26 @@ fn xr_skip_frame(
     }
 }
 
-#[derive(Default)]
 pub struct DefaultXrPlugins {
     pub reqeusted_extensions: XrExtensions,
     pub prefered_blend_mode: XrPreferdBlendMode,
     pub app_info: XrAppInfo,
+    pub enable_pipelined_rendering: bool,
+}
+impl Default for DefaultXrPlugins {
+    fn default() -> Self {
+        Self {
+            reqeusted_extensions: default(),
+            prefered_blend_mode: default(),
+            app_info: default(),
+            enable_pipelined_rendering: true,
+        }
+    }
 }
 
 impl PluginGroup for DefaultXrPlugins {
     fn build(self) -> PluginGroupBuilder {
-        DefaultPlugins
+        let plugins = DefaultPlugins
             .build()
             .set(TaskPoolPlugin {
                 task_pool_options: TaskPoolOptions {
@@ -243,12 +259,12 @@ impl PluginGroup for DefaultXrPlugins {
                     ..default()
                 },
             })
-            // .disable::<PipelinedRenderingPlugin>()
             .disable::<RenderPlugin>()
             .add_before::<RenderPlugin, _>(OpenXrPlugin {
                 prefered_blend_mode: self.prefered_blend_mode,
                 reqeusted_extensions: self.reqeusted_extensions,
                 app_info: self.app_info.clone(),
+                enable_pipelined_rendering: self.enable_pipelined_rendering,
             })
             .add_after::<OpenXrPlugin, _>(XrInitPlugin)
             .add(XrInputPlugin)
@@ -276,7 +292,12 @@ impl PluginGroup for DefaultXrPlugins {
                 #[cfg(target_os = "android")]
                 close_when_requested: true,
                 ..default()
-            })
+            });
+        if !self.enable_pipelined_rendering {
+            plugins.disable::<PipelinedRenderingPlugin>()
+        } else {
+            plugins
+        }
     }
 }
 
@@ -369,11 +390,13 @@ pub fn xr_wait_frame(
             }
         };
         let should_render = world.get_resource::<XrFrameState>().unwrap().should_render;
+        if world.contains_resource::<DoPipelinedRendering>() {
             let mut frame_state = world.resource_mut::<XrFrameState>();
             frame_state.predicted_display_time = xr::Time::from_nanos(
                 frame_state.predicted_display_time.as_nanos()
                     + frame_state.predicted_display_period.as_nanos(),
             );
+        }
         **world.get_resource_mut::<XrShouldRender>().unwrap() = should_render;
         **world.get_resource_mut::<XrHasWaited>().unwrap() = true;
     }

src/xr_input/hands/hand_tracking.rs

@@ -176,9 +176,9 @@ pub fn update_hand_bones(
     };
     let left_hand_data = hand_ref.get_poses(Hand::Left);
     let right_hand_data = hand_ref.get_poses(Hand::Right);
-    if left_hand_data.is_none() || right_hand_data.is_none() {
-        error!("something is very wrong for hand_tracking!! doesn't have data for both hands!");
-    }
+    // if left_hand_data.is_none() || right_hand_data.is_none() {
+    //     error!("something is very wrong for hand_tracking!! doesn't have data for both hands!");
+    // }
 
     bones
         .par_iter_mut()