Jayden/wayvr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more error handling

Browse Source
This commit is contained in:
galister
2024-02-19 01:05:50 +01:00
parent 63b43c0e59
commit 1d9fa95ea0
10 changed files with 125 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/backend/openxr/lines.rs
View File

@@ -49,7 +49,7 @@ impl LinePool {
let tex = command_buffer.texture2d(1, 1, Format::R8G8B8A8_UNORM, &color);
ImageView::new_default(tex).unwrap()
})
.collect::<Vec<_>>();
.collect();
command_buffer.build_and_execute_now();
@@ -59,10 +59,14 @@ impl LinePool {
}
}
pub(super) fn allocate(&mut self, xr: &XrState, graphics: Arc<WlxGraphics>) -> usize {
pub(super) fn allocate(
&mut self,
xr: &XrState,
graphics: Arc<WlxGraphics>,
) -> anyhow::Result<usize> {
let id = AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);
let srd = create_swapchain_render_data(xr, graphics, [1, 1, 1]);
let srd = create_swapchain_render_data(xr, graphics, [1, 1, 1])?;
self.lines.insert(
id,
LineContainer {
@@ -70,7 +74,7 @@ impl LinePool {
maybe_line: None,
},
);
id
Ok(id)
}
pub(super) fn draw_from(
@@ -128,7 +132,7 @@ impl LinePool {
&'a mut self,
xr: &'a XrState,
command_buffer: &mut WlxCommandBuffer,
) -> Vec<xr::CompositionLayerQuad<xr::Vulkan>> {
) -> Result<Vec<xr::CompositionLayerQuad<xr::Vulkan>>, xr::sys::Result> {
let mut quads = Vec::new();
for line in self.lines.values_mut() {
@@ -139,7 +143,7 @@ impl LinePool {
command_buffer,
inner.view,
1.0,
))
)?)
.eye_visibility(xr::EyeVisibility::BOTH)
.layer_flags(xr::CompositionLayerFlags::CORRECT_CHROMATIC_ABERRATION)
.space(&xr.stage)
@@ -152,7 +156,7 @@ impl LinePool {
}
}
quads
Ok(quads)
}
/// the number of lines that are waiting to be drawn

78
src/backend/openxr/mod.rs
View File

@@ -50,9 +50,8 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
}
};
let environment_blend_mode = xr_instance
.enumerate_environment_blend_modes(system, VIEW_TYPE)
.unwrap()[0];
let environment_blend_mode =
xr_instance.enumerate_environment_blend_modes(system, VIEW_TYPE)?[0];
log::info!("Using environment blend mode: {:?}", environment_blend_mode);
let mut app_state = {
@@ -60,7 +59,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
AppState::from_graphics(graphics)?
};
let mut overlays = OverlayContainer::<OpenXrOverlayData>::new(&mut app_state);
let mut overlays = OverlayContainer::<OpenXrOverlayData>::new(&mut app_state)?;
let mut lines = LinePool::new(app_state.graphics.clone());
#[cfg(feature = "osc")]
@@ -85,14 +84,12 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
queue_family_index: app_state.graphics.queue.queue_family_index(),
queue_index: 0,
},
)
.unwrap();
)?;
xr::Session::from_raw(xr_instance.clone(), raw_session, Box::new(()))
};
let stage = session
.create_reference_space(xr::ReferenceSpaceType::STAGE, xr::Posef::IDENTITY)
.unwrap();
let stage =
session.create_reference_space(xr::ReferenceSpaceType::STAGE, xr::Posef::IDENTITY)?;
let mut xr_state = XrState {
instance: xr_instance,
@@ -103,11 +100,11 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
};
let pointer_lines = [
lines.allocate(&xr_state, app_state.graphics.clone()),
lines.allocate(&xr_state, app_state.graphics.clone()),
lines.allocate(&xr_state, app_state.graphics.clone())?,
lines.allocate(&xr_state, app_state.graphics.clone())?,
];
let watch_id = overlays.get_by_name(WATCH_NAME).unwrap().state.id;
let watch_id = overlays.get_by_name(WATCH_NAME).unwrap().state.id; // want panic
let input_source = input::OpenXrInputSource::new(&xr_state)?;
@@ -130,7 +127,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
}
}
while let Some(event) = xr_state.instance.poll_event(&mut event_storage).unwrap() {
while let Some(event) = xr_state.instance.poll_event(&mut event_storage)? {
use xr::Event::*;
match event {
SessionStateChanged(e) => {
@@ -139,11 +136,11 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
log::info!("entered state {:?}", e.state());
match e.state() {
xr::SessionState::READY => {
xr_state.session.begin(VIEW_TYPE).unwrap();
xr_state.session.begin(VIEW_TYPE)?;
session_running = true;
}
xr::SessionState::STOPPING => {
xr_state.session.end().unwrap();
xr_state.session.end()?;
session_running = false;
}
xr::SessionState::EXITING | xr::SessionState::LOSS_PENDING => {
@@ -167,19 +164,17 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
continue 'main_loop;
}
let xr_frame_state = frame_wait.wait().unwrap();
frame_stream.begin().unwrap();
let xr_frame_state = frame_wait.wait()?;
frame_stream.begin()?;
xr_state.predicted_display_time = xr_frame_state.predicted_display_time;
if !xr_frame_state.should_render {
frame_stream
.end(
xr_frame_state.predicted_display_time,
environment_blend_mode,
&[],
)
.unwrap();
frame_stream.end(
xr_frame_state.predicted_display_time,
environment_blend_mode,
&[],
)?;
continue 'main_loop;
}
@@ -214,7 +209,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
}
}
watch_fade(&mut app_state, overlays.mut_by_id(watch_id).unwrap());
watch_fade(&mut app_state, overlays.mut_by_id(watch_id).unwrap()); // want panic
overlays
.iter_mut()
@@ -225,14 +220,11 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
let _ = sender.send_params(&overlays);
};
let (_, views) = xr_state
.session
.locate_views(
VIEW_TYPE,
xr_frame_state.predicted_display_time,
&xr_state.stage,
)
.unwrap();
let (_, views) = xr_state.session.locate_views(
VIEW_TYPE,
xr_frame_state.predicted_display_time,
&xr_state.stage,
)?;
app_state.input_state.hmd = helpers::hmd_pose_from_views(&views);
@@ -254,7 +246,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
}
}
let watch = overlays.mut_by_id(watch_id).unwrap();
let watch = overlays.mut_by_id(watch_id).unwrap(); // want panic
let watch_transform = watch.state.transform;
if !watch.state.want_visible {
watch.state.want_visible = true;
@@ -289,12 +281,12 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
continue;
}
if let Some(quad) = o.present_xr(&xr_state, &mut command_buffer) {
if let Some(quad) = o.present_xr(&xr_state, &mut command_buffer)? {
layers.push((dist_sq, quad));
};
}
for quad in lines.present_xr(&xr_state, &mut command_buffer) {
for quad in lines.present_xr(&xr_state, &mut command_buffer)? {
layers.push((0.0, quad));
}
@@ -307,17 +299,15 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
.map(|f| &f.1 as &xr::CompositionLayerBase<xr::Vulkan>)
.collect::<Vec<_>>();
frame_stream
.end(
xr_state.predicted_display_time,
environment_blend_mode,
&frame_ref,
)
.unwrap();
frame_stream.end(
xr_state.predicted_display_time,
environment_blend_mode,
&frame_ref,
)?;
app_state.hid_provider.on_new_frame();
let watch = overlays.mut_by_id(watch_id).unwrap();
let watch = overlays.mut_by_id(watch_id).unwrap(); // want panic
watch.state.transform = watch_transform;
}

11
src/backend/openxr/overlay.rs
View File

@@ -23,7 +23,7 @@ impl OverlayData<OpenXrOverlayData> {
&'a mut self,
xr: &'a XrState,
command_buffer: &mut WlxCommandBuffer,
) -> Option<xr::CompositionLayerQuad<xr::Vulkan>> {
) -> anyhow::Result<Option<xr::CompositionLayerQuad<xr::Vulkan>>> {
if let Some(new_view) = self.view() {
self.data.last_view = Some(new_view);
}
@@ -32,12 +32,13 @@ impl OverlayData<OpenXrOverlayData> {
view.clone()
} else {
log::warn!("{}: Will not show - image not ready", self.state.name);
return None;
return Ok(None);
};
let extent = my_view.image().extent();
let data = self.data.swapchain.get_or_insert_with(|| {
let srd = create_swapchain_render_data(xr, command_buffer.graphics.clone(), extent);
let srd =
create_swapchain_render_data(xr, command_buffer.graphics.clone(), extent).unwrap(); //TODO
log::info!(
"{}: Created swapchain {}x{}, {} images, {} MB",
@@ -50,7 +51,7 @@ impl OverlayData<OpenXrOverlayData> {
srd
});
let sub_image = data.acquire_present_release(command_buffer, my_view, self.state.alpha);
let sub_image = data.acquire_present_release(command_buffer, my_view, self.state.alpha)?;
let posef = helpers::transform_to_posef(&self.state.transform);
let aspect_ratio = extent[1] as f32 / extent[0] as f32;
@@ -73,7 +74,7 @@ impl OverlayData<OpenXrOverlayData> {
width: scale_x,
height: scale_y,
});
Some(quad)
Ok(Some(quad))
}
pub(super) fn after_input(&mut self, app: &mut AppState) {

51
src/backend/openxr/swapchain.rs
View File

@@ -17,22 +17,18 @@ pub(super) fn create_swapchain_render_data(
xr: &XrState,
graphics: Arc<WlxGraphics>,
extent: [u32; 3],
) -> SwapchainRenderData {
let swapchain = xr
.session
.create_swapchain(&xr::SwapchainCreateInfo {
create_flags: xr::SwapchainCreateFlags::EMPTY,
usage_flags: xr::SwapchainUsageFlags::COLOR_ATTACHMENT
| xr::SwapchainUsageFlags::SAMPLED,
format: graphics.native_format as _,
sample_count: 1,
width: extent[0],
height: extent[1],
face_count: 1,
array_size: 1,
mip_count: 1,
})
.unwrap();
) -> anyhow::Result<SwapchainRenderData> {
let swapchain = xr.session.create_swapchain(&xr::SwapchainCreateInfo {
create_flags: xr::SwapchainCreateFlags::EMPTY,
usage_flags: xr::SwapchainUsageFlags::COLOR_ATTACHMENT | xr::SwapchainUsageFlags::SAMPLED,
format: graphics.native_format as _,
sample_count: 1,
width: extent[0],
height: extent[1],
face_count: 1,
array_size: 1,
mip_count: 1,
})?;
let shaders = graphics.shared_shaders.read().unwrap();
let pipeline = graphics.create_pipeline_dynamic(
@@ -58,21 +54,20 @@ pub(super) fn create_swapchain_render_data(
usage: ImageUsage::COLOR_ATTACHMENT,
..Default::default()
},
)
.unwrap()
)?
};
// SAFETY: OpenXR guarantees that the image is a swapchain image, thus has memory backing it.
let image = Arc::new(unsafe { raw_image.assume_bound() });
ImageView::new_default(image).unwrap()
Ok(ImageView::new_default(image)?)
})
.collect();
.collect::<anyhow::Result<SmallVec<[Arc<ImageView>; 4]>>>()?;
SwapchainRenderData {
Ok(SwapchainRenderData {
swapchain,
pipeline,
images,
extent,
}
})
}
pub(super) struct SwapchainRenderData {
@@ -88,9 +83,9 @@ impl SwapchainRenderData {
command_buffer: &mut WlxCommandBuffer,
view: Arc<ImageView>,
alpha: f32,
) -> xr::SwapchainSubImage<xr::Vulkan> {
let idx = self.swapchain.acquire_image().unwrap() as usize;
self.swapchain.wait_image(xr::Duration::INFINITE).unwrap();
) -> Result<xr::SwapchainSubImage<xr::Vulkan>, xr::sys::Result> {
let idx = self.swapchain.acquire_image()? as usize;
self.swapchain.wait_image(xr::Duration::INFINITE)?;
let render_target = &mut self.images[idx];
command_buffer.begin_rendering(render_target.clone());
@@ -112,9 +107,9 @@ impl SwapchainRenderData {
command_buffer.run_ref(&pass);
command_buffer.end_rendering();
self.swapchain.release_image().unwrap();
self.swapchain.release_image()?;
xr::SwapchainSubImage::new()
Ok(xr::SwapchainSubImage::new()
.swapchain(&self.swapchain)
.image_rect(xr::Rect2Di {
offset: xr::Offset2Di { x: 0, y: 0 },
@@ -123,6 +118,6 @@ impl SwapchainRenderData {
height: target_extent[1] as _,
},
})
.image_array_index(0)
.image_array_index(0))
}
}