Use thiserror in re_renderer everywhere except shader file reloading (#4759)

### What

* part of #1845 

Started also removing it the file resolver/reloader but it's super
tedious and makes errors worse since during include resolve we often
want to stack errors. We can revisit that if we ever move out the shader
reloading or when we tackle

* #2664 

but otherwise I don't think it's worth it.

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using newly built examples:
[app.rerun.io](https://app.rerun.io/pr/4759/index.html)
* Using examples from latest `main` build:
[app.rerun.io](https://app.rerun.io/pr/4759/index.html?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[app.rerun.io](https://app.rerun.io/pr/4759/index.html?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG

- [PR Build Summary](https://build.rerun.io/pr/4759)
- [Docs
preview](https://rerun.io/preview/79d6075baae6651555be0431005e07817440c3b5/docs)
<!--DOCS-PREVIEW-->
- [Examples
preview](https://rerun.io/preview/79d6075baae6651555be0431005e07817440c3b5/examples)
<!--EXAMPLES-PREVIEW-->
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

Author: Wumpf

crates/re_renderer/src/config.rs

@@ -23,6 +23,21 @@ pub enum DeviceTier {
     //HighEnd
 }
 
+#[derive(thiserror::Error, Debug)]
+pub enum InsufficientDeviceCapabilities {
+    #[error("Adapter does not support the minimum shader model required. Supported is {actual:?} but required is {required:?}")]
+    TooLowShaderModel {
+        required: wgpu::ShaderModel,
+        actual: wgpu::ShaderModel,
+    },
+
+    #[error("Adapter does not have all the required capability flags required. Supported are {actual:?} but required are {required:?}")]
+    MissingCapabilitiesFlags {
+        required: wgpu::DownlevelFlags,
+        actual: wgpu::DownlevelFlags,
+    },
+}
+
 /// Capabilities of a given device.
 ///
 /// Generally, this is a higher level interpretation of [`wgpu::Limits`].
@@ -115,25 +130,27 @@ impl DeviceCaps {
     /// Checks if passed downlevel capabilities support the given device tier.
     pub fn check_downlevel_capabilities(
         &self,
-        downlevel_capabilities: &wgpu::DownlevelCapabilities,
-    ) -> anyhow::Result<()> {
-        let required_downlevel_capabilities = self.required_downlevel_capabilities();
-        anyhow::ensure!(
-            downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
-            "Adapter does not support the minimum shader model required to run re_renderer at the {:?} tier: {:?}",
-            self.tier,
-            required_downlevel_capabilities.shader_model
-        );
-        anyhow::ensure!(
-            downlevel_capabilities
-                .flags
-                .contains(required_downlevel_capabilities.flags),
-            "Adapter does not support the downlevel capabilities required to run re_renderer at the {:?} tier: {:?}",
-            self.tier,
-            required_downlevel_capabilities.flags - downlevel_capabilities.flags
-        );
-
-        Ok(())
+        capabilities: &wgpu::DownlevelCapabilities,
+    ) -> Result<(), InsufficientDeviceCapabilities> {
+        let wgpu::DownlevelCapabilities {
+            flags,
+            limits: _,
+            shader_model,
+        } = self.required_downlevel_capabilities();
+
+        if capabilities.shader_model < shader_model {
+            Err(InsufficientDeviceCapabilities::TooLowShaderModel {
+                required: shader_model,
+                actual: capabilities.shader_model,
+            })
+        } else if !capabilities.flags.contains(flags) {
+            Err(InsufficientDeviceCapabilities::MissingCapabilitiesFlags {
+                required: flags,
+                actual: capabilities.flags,
+            })
+        } else {
+            Ok(())
+        }
     }
 }
 

crates/re_renderer/src/importer/gltf.rs

@@ -1,27 +1,54 @@
 use std::sync::Arc;
 
 use ahash::{HashMap, HashMapExt};
-use anyhow::Context as _;
 use gltf::texture::WrappingMode;
 use itertools::Itertools;
 use smallvec::SmallVec;
 
 use crate::{
-    mesh::{Material, Mesh},
+    mesh::{Material, Mesh, MeshError},
     renderer::MeshInstance,
     resource_managers::{
-        GpuMeshHandle, GpuTexture2D, ResourceLifeTime, Texture2DCreationDesc, TextureManager2D,
+        GpuMeshHandle, GpuTexture2D, ResourceLifeTime, ResourceManagerError, Texture2DCreationDesc,
+        TextureManager2D,
     },
     RenderContext, Rgba32Unmul,
 };
 
+#[derive(thiserror::Error, Debug)]
+pub enum GltfImportError {
+    #[error(transparent)]
+    GltfLoading(#[from] gltf::Error),
+
+    #[error(transparent)]
+    ResourceManager(#[from] ResourceManagerError),
+
+    #[error(transparent)]
+    MeshError(#[from] MeshError),
+
+    #[error("Unsupported texture format {0:?}.")]
+    UnsupportedTextureFormat(gltf::image::Format),
+
+    #[error("Mesh {mesh_name:?} has multiple sets of texture coordinates. Only a single one is supported.")]
+    MultipleTextureCoordinateSets { mesh_name: String },
+
+    #[error("Mesh {mesh_name:?} has no triangles.")]
+    NoIndices { mesh_name: String },
+
+    #[error("Mesh {mesh_name:?} has no vertex positions.")]
+    NoPositions { mesh_name: String },
+
+    #[error("Mesh {mesh_name:?} has no triangle primitives.")]
+    NoTrianglePrimitives { mesh_name: String },
+}
+
 /// Loads both gltf and glb into the mesh & texture manager.
 pub fn load_gltf_from_buffer(
     mesh_name: &str,
     buffer: &[u8],
     lifetime: ResourceLifeTime,
     ctx: &RenderContext,
-) -> anyhow::Result<Vec<MeshInstance>> {
+) -> Result<Vec<MeshInstance>, GltfImportError> {
     re_tracing::profile_function!();
 
     let (doc, buffers, images) = {
@@ -44,7 +71,7 @@ pub fn load_gltf_from_buffer(
                     crate::pad_rgb_to_rgba(&image.pixels, 255),
                 )
             } else {
-                anyhow::bail!("Unsupported texture format {:?}", image.format);
+                return Err(GltfImportError::UnsupportedTextureFormat(image.format));
             }
         };
 
@@ -93,8 +120,7 @@ pub fn load_gltf_from_buffer(
     for ref mesh in doc.meshes() {
         re_tracing::profile_scope!("mesh");
 
-        let re_mesh = import_mesh(mesh, &buffers, &images_as_textures, &ctx.texture_manager_2d)
-            .with_context(|| format!("mesh {} (name {:?})", mesh.index(), mesh.name()))?;
+        let re_mesh = import_mesh(mesh, &buffers, &images_as_textures, &ctx.texture_manager_2d)?;
         meshes.insert(
             mesh.index(),
             (
@@ -140,9 +166,11 @@ fn import_mesh(
     buffers: &[gltf::buffer::Data],
     gpu_image_handles: &[GpuTexture2D],
     texture_manager: &TextureManager2D, //imported_materials: HashMap<usize, Material>,
-) -> anyhow::Result<Mesh> {
+) -> Result<Mesh, GltfImportError> {
     re_tracing::profile_function!();
 
+    let mesh_name = mesh.name().map_or("<unknown", |f| f).to_owned();
+
     let mut triangle_indices = Vec::new();
     let mut vertex_positions = Vec::new();
     let mut vertex_colors = Vec::new();
@@ -171,13 +199,13 @@ fn import_mesh(
                     .map(glam::UVec3::from),
             );
         } else {
-            anyhow::bail!("Gltf primitives must have indices");
+            return Err(GltfImportError::NoIndices { mesh_name });
         }
 
         if let Some(primitive_positions) = reader.read_positions() {
             vertex_positions.extend(primitive_positions.map(glam::Vec3::from));
         } else {
-            anyhow::bail!("Gltf primitives must have positions");
+            return Err(GltfImportError::NoPositions { mesh_name });
         }
 
         if let Some(colors) = reader.read_colors(set) {
@@ -206,10 +234,9 @@ fn import_mesh(
         let pbr_material = primitive_material.pbr_metallic_roughness();
 
         let albedo = if let Some(texture) = pbr_material.base_color_texture() {
-            anyhow::ensure!(
-                texture.tex_coord() == 0,
-                "Only a single set of texture coordinates is supported"
-            );
+            if texture.tex_coord() != 0 {
+                return Err(GltfImportError::MultipleTextureCoordinateSets { mesh_name });
+            }
             let texture = &texture.texture();
 
             let sampler = &texture.sampler();
@@ -259,7 +286,7 @@ fn import_mesh(
         });
     }
     if vertex_positions.is_empty() || triangle_indices.is_empty() {
-        anyhow::bail!("empty mesh");
+        return Err(GltfImportError::NoTrianglePrimitives { mesh_name });
     }
 
     let mesh = Mesh {

crates/re_renderer/src/importer/obj.rs

@@ -1,22 +1,33 @@
 use std::sync::Arc;
 
-use anyhow::Context as _;
 use smallvec::smallvec;
 
 use crate::{
-    mesh::{Material, Mesh},
+    mesh::{Material, Mesh, MeshError},
     renderer::MeshInstance,
-    resource_managers::ResourceLifeTime,
+    resource_managers::{ResourceLifeTime, ResourceManagerError},
     RenderContext, Rgba32Unmul,
 };
 
+#[derive(thiserror::Error, Debug)]
+pub enum ObjImportError {
+    #[error(transparent)]
+    ObjLoading(#[from] tobj::LoadError),
+
+    #[error(transparent)]
+    Mesh(#[from] MeshError),
+
+    #[error(transparent)]
+    ResourceManager(#[from] ResourceManagerError),
+}
+
 /// Load a [Wavefront .obj file](https://en.wikipedia.org/wiki/Wavefront_.obj_file)
 /// into the mesh & texture manager.
 pub fn load_obj_from_buffer(
     buffer: &[u8],
     lifetime: ResourceLifeTime,
     ctx: &RenderContext,
-) -> anyhow::Result<Vec<MeshInstance>> {
+) -> Result<Vec<MeshInstance>, ObjImportError> {
     re_tracing::profile_function!();
 
     let (models, _materials) = tobj::load_obj_buf(
@@ -27,8 +38,7 @@ pub fn load_obj_from_buffer(
             ..Default::default()
         },
         |_material_path| Err(tobj::LoadError::MaterialParseError),
-    )
-    .context("failed loading obj")?;
+    )?;
 
     // TODO(andreas) Merge all obj meshes into a single re_renderer mesh with multiple materials.
     models

crates/re_renderer/src/renderer/mesh_renderer.rs

@@ -12,7 +12,7 @@ use crate::{
     draw_phases::{DrawPhase, OutlineMaskProcessor},
     include_shader_module,
     mesh::{gpu_data::MaterialUniformBuffer, mesh_vertices, GpuMesh, Mesh},
-    resource_managers::{GpuMeshHandle, ResourceHandle},
+    resource_managers::{GpuMeshHandle, ResourceHandle, ResourceManagerError},
     view_builder::ViewBuilder,
     wgpu_resources::{
         BindGroupLayoutDesc, BufferDesc, GpuBindGroupLayoutHandle, GpuBuffer,
@@ -151,7 +151,10 @@ impl MeshDrawData {
     /// Try bundling all mesh instances into a single draw data instance whenever possible.
     /// If you pass zero mesh instances, subsequent drawing will do nothing.
     /// Mesh data itself is gpu uploaded if not already present.
-    pub fn new(ctx: &RenderContext, instances: &[MeshInstance]) -> anyhow::Result<Self> {
+    pub fn new(
+        ctx: &RenderContext,
+        instances: &[MeshInstance],
+    ) -> Result<MeshDrawData, ResourceManagerError> {
         re_tracing::profile_function!();
 
         let _mesh_renderer = ctx.renderer::<MeshRenderer>();

crates/re_renderer/src/view_builder.rs

@@ -1,4 +1,3 @@
-use anyhow::Context;
 use parking_lot::RwLock;
 use std::sync::Arc;
 
@@ -517,8 +516,7 @@ impl ViewBuilder {
                     phase,
                     pass,
                     queued_draw.draw_data.as_ref(),
-                )
-                .with_context(|| format!("draw call during phase {phase:?}"));
+                );
                 if let Err(err) = res {
                     re_log::error!(renderer=%queued_draw.renderer_name, %err,
                         "renderer failed to draw");