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

even more error handling

Browse Source
This commit is contained in:
galister
2024-02-19 03:21:00 +01:00
parent 1d9fa95ea0
commit 5d812c3b09
16 changed files with 541 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -31,8 +31,9 @@ pub(super) struct LinePool {
}
impl LinePool {
pub(super) fn new(graphics: Arc<WlxGraphics>) -> Self {
let mut command_buffer = graphics.create_command_buffer(CommandBufferUsage::OneTimeSubmit);
pub(super) fn new(graphics: Arc<WlxGraphics>) -> anyhow::Result<Self> {
let mut command_buffer =
graphics.create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
// TODO customizable colors
let colors = [
@@ -43,20 +44,22 @@ impl LinePool {
[0xff, 0x00, 0x00, 0xff],
];
let views = colors
let views: anyhow::Result<Vec<Arc<ImageView>>> = colors
.into_iter()
.map(|color| {
let tex = command_buffer.texture2d(1, 1, Format::R8G8B8A8_UNORM, &color);
ImageView::new_default(tex).unwrap()
})
.map(
|color| match command_buffer.texture2d(1, 1, Format::R8G8B8A8_UNORM, &color) {
Ok(tex) => ImageView::new_default(tex).map_err(|e| anyhow::anyhow!(e)),
Err(e) => Err(e),
},
)
.collect();
command_buffer.build_and_execute_now();
command_buffer.build_and_execute_now()?;
LinePool {
Ok(LinePool {
lines: IdMap::new(),
colors: views,
}
colors: views?,
})
}
pub(super) fn allocate(
@@ -132,7 +135,7 @@ impl LinePool {
&'a mut self,
xr: &'a XrState,
command_buffer: &mut WlxCommandBuffer,
) -> Result<Vec<xr::CompositionLayerQuad<xr::Vulkan>>, xr::sys::Result> {
) -> anyhow::Result<Vec<xr::CompositionLayerQuad<xr::Vulkan>>> {
let mut quads = Vec::new();
for line in self.lines.values_mut() {

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

@@ -55,12 +55,12 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
log::info!("Using environment blend mode: {:?}", environment_blend_mode);
let mut app_state = {
let graphics = WlxGraphics::new_openxr(xr_instance.clone(), system);
let graphics = WlxGraphics::new_openxr(xr_instance.clone(), system)?;
AppState::from_graphics(graphics)?
};
let mut overlays = OverlayContainer::<OpenXrOverlayData>::new(&mut app_state)?;
let mut lines = LinePool::new(app_state.graphics.clone());
let mut lines = LinePool::new(app_state.graphics.clone())?;
#[cfg(feature = "osc")]
let mut osc_sender =
@@ -211,9 +211,9 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
watch_fade(&mut app_state, overlays.mut_by_id(watch_id).unwrap()); // want panic
overlays
.iter_mut()
.for_each(|o| o.after_input(&mut app_state));
for o in overlays.iter_mut() {
o.after_input(&mut app_state)?;
}
#[cfg(feature = "osc")]
if let Some(ref mut sender) = osc_sender {
@@ -260,7 +260,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
let mut layers = vec![];
let mut command_buffer = app_state
.graphics
.create_command_buffer(CommandBufferUsage::OneTimeSubmit);
.create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
for o in overlays.iter_mut() {
if !o.state.want_visible {
@@ -268,11 +268,11 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
}
if !o.data.init {
o.init(&mut app_state);
o.init(&mut app_state)?;
o.data.init = true;
}
o.render(&mut app_state);
o.render(&mut app_state)?;
let dist_sq = (app_state.input_state.hmd.translation - o.state.transform.translation)
.length_squared();
@@ -290,7 +290,7 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
layers.push((0.0, quad));
}
command_buffer.build_and_execute_now();
command_buffer.build_and_execute_now()?;
layers.sort_by(|a, b| b.0.total_cmp(&a.0));

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

@@ -77,14 +77,15 @@ impl OverlayData<OpenXrOverlayData> {
Ok(Some(quad))
}
pub(super) fn after_input(&mut self, app: &mut AppState) {
pub(super) fn after_input(&mut self, app: &mut AppState) -> anyhow::Result<()> {
if self.data.last_visible != self.state.want_visible {
if self.state.want_visible {
self.backend.resume(app);
self.backend.resume(app)?;
} else {
self.backend.pause(app);
self.backend.pause(app)?;
}
}
self.data.last_visible = self.state.want_visible;
Ok(())
}
}

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

@@ -1,5 +1,6 @@
use std::sync::Arc;
use anyhow::bail;
use ash::vk;
use openxr as xr;
@@ -30,16 +31,17 @@ pub(super) fn create_swapchain_render_data(
mip_count: 1,
})?;
let shaders = graphics.shared_shaders.read().unwrap();
let Ok(shaders) = graphics.shared_shaders.read() else {
bail!("Failed to lock shared shaders for reading");
};
let pipeline = graphics.create_pipeline_dynamic(
shaders.get("vert_common").unwrap().clone(),
shaders.get("frag_srgb").unwrap().clone(),
shaders.get("vert_common").unwrap().clone(), // want panic
shaders.get("frag_srgb").unwrap().clone(), // want panic
graphics.native_format,
);
)?;
let images = swapchain
.enumerate_images()
.unwrap()
.enumerate_images()?
.into_iter()
.map(|handle| {
let vk_image = vk::Image::from_raw(handle);
@@ -83,29 +85,29 @@ impl SwapchainRenderData {
command_buffer: &mut WlxCommandBuffer,
view: Arc<ImageView>,
alpha: f32,
) -> Result<xr::SwapchainSubImage<xr::Vulkan>, xr::sys::Result> {
) -> anyhow::Result<xr::SwapchainSubImage<xr::Vulkan>> {
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());
command_buffer.begin_rendering(render_target.clone())?;
let target_extent = render_target.image().extent();
let set0 = self
.pipeline
.uniform_sampler(0, view.clone(), Filter::Linear);
.uniform_sampler(0, view.clone(), Filter::Linear)?;
let set1 = self.pipeline.uniform_buffer(1, vec![alpha]);
let set1 = self.pipeline.uniform_buffer(1, vec![alpha])?;
let pass = self.pipeline.create_pass(
[target_extent[0] as _, target_extent[1] as _],
command_buffer.graphics.quad_verts.clone(),
command_buffer.graphics.quad_indices.clone(),
vec![set0, set1],
);
command_buffer.run_ref(&pass);
command_buffer.end_rendering();
)?;
command_buffer.run_ref(&pass)?;
command_buffer.end_rendering()?;
self.swapchain.release_image()?;