frame jitter stop

crates/bevy_openxr/src/init.rs

@@ -345,6 +345,7 @@ fn create_xr_session_inner(
     world.insert_resource(images.clone());
     world.insert_resource(graphics_info.clone());
     world.insert_resource(stage.clone());
+    world.insert_resource(frame_stream.clone());
     world.insert_resource(XrRenderResources {
         session,
         frame_stream,

crates/bevy_openxr/src/lib.rs

@@ -1,6 +1,6 @@
 use bevy::{
     app::{PluginGroup, PluginGroupBuilder},
-    render::RenderPlugin,
+    render::{pipelined_rendering::PipelinedRenderingPlugin, RenderPlugin},
     utils::default,
 };
 use bevy_xr::camera::XrCameraPlugin;
@@ -21,6 +21,7 @@ pub fn add_xr_plugins<G: PluginGroup>(plugins: G) -> PluginGroupBuilder {
     plugins
         .build()
         .disable::<RenderPlugin>()
+        .disable::<PipelinedRenderingPlugin>()
         .add_before::<RenderPlugin, _>(bevy_xr::session::XrSessionPlugin)
         .add_before::<RenderPlugin, _>(XrInitPlugin {
             app_info: default(),

crates/bevy_openxr/src/render.rs

@@ -32,13 +32,12 @@ impl Plugin for XrRenderPlugin {
             )
                 .after(begin_xr_session),
         )
-        .add_systems(PostUpdate, update_views.run_if(session_running));
+        .add_systems(PreUpdate, update_views.run_if(session_running));
         // .add_systems(Startup, init_views);
         app.sub_app_mut(RenderApp).add_systems(
             Render,
             (
-                (begin_frame, insert_texture_views)
-                    .chain()
+                insert_texture_views
                     .in_set(RenderSet::PrepareAssets)
                     .before(render_system),
                 end_frame.in_set(RenderSet::Cleanup),
@@ -84,14 +83,19 @@ pub fn init_views(
     commands.insert_resource(XrViews(views));
 }
 
-pub fn wait_frame(mut frame_waiter: ResMut<XrFrameWaiter>, mut commands: Commands) {
+pub fn wait_frame(
+    mut frame_waiter: ResMut<XrFrameWaiter>,
+    mut commands: Commands,
+    frame_stream: ResMut<XrFrameStream>,
+) {
     let _span = info_span!("xr_wait_frame");
     let state = frame_waiter.wait().expect("Failed to wait frame");
     // Here we insert the predicted display time for when this frame will be displayed.
     // TODO: don't add predicted_display_period if pipelined rendering plugin not enabled
     commands.insert_resource(XrTime(openxr::Time::from_nanos(
-        state.predicted_display_time.as_nanos() + state.predicted_display_period.as_nanos(),
+        state.predicted_display_time.as_nanos(),
     )));
+    frame_stream.begin().expect("Failed to begin frame");
 }
 
 pub fn update_views(
@@ -247,10 +251,6 @@ fn calculate_projection(near_z: f32, fov: openxr::Fovf) -> Mat4 {
     Mat4::from_cols_array(&cols)
 }
 
-pub fn begin_frame(mut frame_stream: ResMut<XrFrameStream>) {
-    frame_stream.begin().expect("Failed to begin frame");
-}
-
 pub fn insert_texture_views(
     swapchain_images: Res<XrSwapchainImages>,
     mut swapchain: ResMut<XrSwapchain>,

crates/bevy_openxr/src/resources.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use crate::error::XrError;
 use crate::graphics::*;
@@ -92,7 +92,7 @@ impl XrInstance {
             info.0;
             info => {
                 let (session, frame_waiter, frame_stream) = self.0.create_session::<Api>(system_id, &info)?;
-                Ok((session.into(), XrFrameWaiter(frame_waiter), XrFrameStream(Api::wrap(frame_stream))))
+                Ok((session.into(), XrFrameWaiter(frame_waiter), XrFrameStream(Api::wrap(Arc::new(Mutex::new(frame_stream))))))
             }
         )
     }
@@ -136,18 +136,18 @@ impl XrSession {
     }
 }
 
-#[derive(Resource)]
+#[derive(Resource, Clone)]
 pub struct XrFrameStream(pub(crate) GraphicsWrap<Self>);
 
 impl GraphicsType for XrFrameStream {
-    type Inner<G: GraphicsExt> = openxr::FrameStream<G>;
+    type Inner<G: GraphicsExt> = Arc<Mutex<openxr::FrameStream<G>>>;
 }
 
 impl XrFrameStream {
-    pub fn begin(&mut self) -> openxr::Result<()> {
+    pub fn begin(&self) -> openxr::Result<()> {
         graphics_match!(
-            &mut self.0;
-            stream => stream.begin()
+            &self.0;
+            stream => stream.lock().unwrap().begin()
         )
     }
 
@@ -158,8 +158,9 @@ impl XrFrameStream {
         layers: &[&dyn CompositionLayer],
     ) -> Result<()> {
         graphics_match!(
-            &mut self.0;
+            &self.0;
             stream => {
+                let mut stream = stream.lock().unwrap();
                 let mut new_layers = vec![];
 
                 for (i, layer) in layers.into_iter().enumerate() {