Remove thiserror from bevy_render

crates/bevy_render/Cargo.toml

@@ -78,7 +78,11 @@ naga = { version = "22", features = ["wgsl-in"] }
 serde = { version = "1", features = ["derive"] }
 bytemuck = { version = "1.5", features = ["derive", "must_cast"] }
 downcast-rs = "1.2.0"
-thiserror = "1.0"
+derive_more = { version = "1", default-features = false, features = [
+  "error",
+  "from",
+  "display",
+] }
 futures-lite = "2.0.1"
 ktx2 = { version = "0.3.0", optional = true }
 # For transcoding of UASTC/ETC1S universal formats, and for .basis file support

crates/bevy_render/src/camera/camera.rs

@@ -37,6 +37,7 @@ use bevy_window::{
     WindowScaleFactorChanged,
 };
 use core::ops::Range;
+use derive_more::derive::From;
 use wgpu::{BlendState, TextureFormat, TextureUsages};
 
 use super::{ClearColorConfig, Projection};
@@ -710,7 +711,7 @@ impl CameraRenderGraph {
 
 /// The "target" that a [`Camera`] will render to. For example, this could be a [`Window`]
 /// swapchain or an [`Image`].
-#[derive(Debug, Clone, Reflect)]
+#[derive(Debug, Clone, Reflect, From)]
 pub enum RenderTarget {
     /// Window to which the camera's view is rendered.
     Window(WindowRef),
@@ -727,16 +728,10 @@ impl Default for RenderTarget {
     }
 }
 
-impl From<Handle<Image>> for RenderTarget {
-    fn from(handle: Handle<Image>) -> Self {
-        Self::Image(handle)
-    }
-}
-
 /// Normalized version of the render target.
 ///
 /// Once we have this we shouldn't need to resolve it down anymore.
-#[derive(Debug, Clone, Reflect, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, Reflect, PartialEq, Eq, Hash, PartialOrd, Ord, From)]
 pub enum NormalizedRenderTarget {
     /// Window to which the camera's view is rendered.
     Window(NormalizedWindowRef),

crates/bevy_render/src/camera/clear_color.rs

@@ -3,10 +3,11 @@ use bevy_color::Color;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::prelude::*;
 use bevy_reflect::prelude::*;
+use derive_more::derive::From;
 use serde::{Deserialize, Serialize};
 
 /// For a camera, specifies the color used to clear the viewport before rendering.
-#[derive(Reflect, Serialize, Deserialize, Copy, Clone, Debug, Default)]
+#[derive(Reflect, Serialize, Deserialize, Copy, Clone, Debug, Default, From)]
 #[reflect(Serialize, Deserialize, Default)]
 pub enum ClearColorConfig {
     /// The clear color is taken from the world's [`ClearColor`] resource.
@@ -20,12 +21,6 @@ pub enum ClearColorConfig {
     None,
 }
 
-impl From<Color> for ClearColorConfig {
-    fn from(color: Color) -> Self {
-        Self::Custom(color)
-    }
-}
-
 /// A [`Resource`] that stores the color that is used to clear the screen between frames.
 ///
 /// This color appears as the "background" color for simple apps,

crates/bevy_render/src/camera/projection.rs

@@ -11,6 +11,7 @@ use bevy_reflect::{
     std_traits::ReflectDefault, GetTypeRegistration, Reflect, ReflectDeserialize, ReflectSerialize,
 };
 use bevy_transform::{components::GlobalTransform, TransformSystem};
+use derive_more::derive::From;
 use serde::{Deserialize, Serialize};
 
 /// Adds [`Camera`](crate::camera::Camera) driver systems for a given projection type.
@@ -98,25 +99,13 @@ pub trait CameraProjection {
 }
 
 /// A configurable [`CameraProjection`] that can select its projection type at runtime.
-#[derive(Component, Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect, From)]
 #[reflect(Component, Default, Debug)]
 pub enum Projection {
     Perspective(PerspectiveProjection),
     Orthographic(OrthographicProjection),
 }
 
-impl From<PerspectiveProjection> for Projection {
-    fn from(p: PerspectiveProjection) -> Self {
-        Self::Perspective(p)
-    }
-}
-
-impl From<OrthographicProjection> for Projection {
-    fn from(p: OrthographicProjection) -> Self {
-        Self::Orthographic(p)
-    }
-}
-
 impl CameraProjection for Projection {
     fn get_clip_from_view(&self) -> Mat4 {
         match self {

crates/bevy_render/src/mesh/components.rs

@@ -4,6 +4,7 @@ use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_transform::components::Transform;
+use derive_more::derive::From;
 
 /// A component for rendering 2D meshes, typically with a [`MeshMaterial2d`] using a [`ColorMaterial`].
 ///
@@ -35,17 +36,11 @@ use bevy_transform::components::Transform;
 ///     ));
 /// }
 /// ```
-#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq)]
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
 #[reflect(Component, Default)]
 #[require(Transform, Visibility)]
 pub struct Mesh2d(pub Handle<Mesh>);
 
-impl From<Handle<Mesh>> for Mesh2d {
-    fn from(handle: Handle<Mesh>) -> Self {
-        Self(handle)
-    }
-}
-
 impl From<Mesh2d> for AssetId<Mesh> {
     fn from(mesh: Mesh2d) -> Self {
         mesh.id()
@@ -91,17 +86,11 @@ impl From<&Mesh2d> for AssetId<Mesh> {
 ///     ));
 /// }
 /// ```
-#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq)]
+#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
 #[reflect(Component, Default)]
 #[require(Transform, Visibility)]
 pub struct Mesh3d(pub Handle<Mesh>);
 
-impl From<Handle<Mesh>> for Mesh3d {
-    fn from(handle: Handle<Mesh>) -> Self {
-        Self(handle)
-    }
-}
-
 impl From<Mesh3d> for AssetId<Mesh> {
     fn from(mesh: Mesh3d) -> Self {
         mesh.id()

crates/bevy_render/src/render_asset.rs

@@ -16,13 +16,13 @@ use bevy_utils::{
     HashMap, HashSet,
 };
 use core::marker::PhantomData;
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Display)]
 pub enum PrepareAssetError<E: Send + Sync + 'static> {
-    #[error("Failed to prepare asset")]
+    #[display("Failed to prepare asset")]
     RetryNextUpdate(E),
-    #[error("Failed to build bind group: {0}")]
+    #[display("Failed to build bind group: {_0}")]
     AsBindGroupError(AsBindGroupError),
 }
 

crates/bevy_render/src/render_graph/context.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use alloc::borrow::Cow;
 use bevy_ecs::entity::Entity;
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 use super::{InternedRenderSubGraph, RenderSubGraph};
 
@@ -231,19 +231,21 @@ impl<'a> RenderGraphContext<'a> {
     }
 }
 
-#[derive(Error, Debug, Eq, PartialEq)]
+#[derive(Error, Display, Debug, Eq, PartialEq)]
 pub enum RunSubGraphError {
-    #[error("attempted to run sub-graph `{0:?}`, but it does not exist")]
+    #[display("attempted to run sub-graph `{_0:?}`, but it does not exist")]
+    #[error(ignore)]
     MissingSubGraph(InternedRenderSubGraph),
-    #[error("attempted to pass inputs to sub-graph `{0:?}`, which has no input slots")]
+    #[display("attempted to pass inputs to sub-graph `{_0:?}`, which has no input slots")]
+    #[error(ignore)]
     SubGraphHasNoInputs(InternedRenderSubGraph),
-    #[error("sub graph (name: `{graph_name:?}`) could not be run because slot `{slot_name}` at index {slot_index} has no value")]
+    #[display("sub graph (name: `{graph_name:?}`) could not be run because slot `{slot_name}` at index {slot_index} has no value")]
     MissingInput {
         slot_index: usize,
         slot_name: Cow<'static, str>,
         graph_name: InternedRenderSubGraph,
     },
-    #[error("attempted to use the wrong type for input slot")]
+    #[display("attempted to use the wrong type for input slot")]
     MismatchedInputSlotType {
         graph_name: InternedRenderSubGraph,
         slot_index: usize,
@@ -253,23 +255,25 @@ pub enum RunSubGraphError {
     },
 }
 
-#[derive(Error, Debug, Eq, PartialEq)]
+#[derive(Error, Display, Debug, Eq, PartialEq)]
 pub enum OutputSlotError {
-    #[error("output slot `{0:?}` does not exist")]
+    #[display("output slot `{_0:?}` does not exist")]
+    #[error(ignore)]
     InvalidSlot(SlotLabel),
-    #[error("attempted to output a value of type `{actual}` to output slot `{label:?}`, which has type `{expected}`")]
+    #[display("attempted to output a value of type `{actual}` to output slot `{label:?}`, which has type `{expected}`")]
     MismatchedSlotType {
         label: SlotLabel,
         expected: SlotType,
         actual: SlotType,
     },
 }
 
-#[derive(Error, Debug, Eq, PartialEq)]
+#[derive(Error, Display, Debug, Eq, PartialEq)]
 pub enum InputSlotError {
-    #[error("input slot `{0:?}` does not exist")]
+    #[display("input slot `{_0:?}` does not exist")]
+    #[error(ignore)]
     InvalidSlot(SlotLabel),
-    #[error("attempted to retrieve a value of type `{actual}` from input slot `{label:?}`, which has type `{expected}`")]
+    #[display("attempted to retrieve a value of type `{actual}` from input slot `{label:?}`, which has type `{expected}`")]
     MismatchedSlotType {
         label: SlotLabel,
         expected: SlotType,

crates/bevy_render/src/render_graph/mod.rs

@@ -12,40 +12,45 @@ pub use graph::*;
 pub use node::*;
 pub use node_slot::*;
 
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
-#[derive(Error, Debug, Eq, PartialEq)]
+#[derive(Error, Display, Debug, Eq, PartialEq)]
 pub enum RenderGraphError {
-    #[error("node {0:?} does not exist")]
+    #[display("node {_0:?} does not exist")]
+    #[error(ignore)]
     InvalidNode(InternedRenderLabel),
-    #[error("output node slot does not exist")]
+    #[display("output node slot does not exist")]
+    #[error(ignore)]
     InvalidOutputNodeSlot(SlotLabel),
-    #[error("input node slot does not exist")]
+    #[display("input node slot does not exist")]
+    #[error(ignore)]
     InvalidInputNodeSlot(SlotLabel),
-    #[error("node does not match the given type")]
+    #[display("node does not match the given type")]
     WrongNodeType,
-    #[error("attempted to connect output slot {output_slot} from node {output_node:?} to incompatible input slot {input_slot} from node {input_node:?}")]
+    #[display("attempted to connect output slot {output_slot} from node {output_node:?} to incompatible input slot {input_slot} from node {input_node:?}")]
     MismatchedNodeSlots {
         output_node: InternedRenderLabel,
         output_slot: usize,
         input_node: InternedRenderLabel,
         input_slot: usize,
     },
-    #[error("attempted to add an edge that already exists")]
+    #[display("attempted to add an edge that already exists")]
+    #[error(ignore)]
     EdgeAlreadyExists(Edge),
-    #[error("attempted to remove an edge that does not exist")]
+    #[display("attempted to remove an edge that does not exist")]
+    #[error(ignore)]
     EdgeDoesNotExist(Edge),
-    #[error("node {node:?} has an unconnected input slot {input_slot}")]
+    #[display("node {node:?} has an unconnected input slot {input_slot}")]
     UnconnectedNodeInputSlot {
         node: InternedRenderLabel,
         input_slot: usize,
     },
-    #[error("node {node:?} has an unconnected output slot {output_slot}")]
+    #[display("node {node:?} has an unconnected output slot {output_slot}")]
     UnconnectedNodeOutputSlot {
         node: InternedRenderLabel,
         output_slot: usize,
     },
-    #[error("node {node:?} input slot {input_slot} already occupied by {occupied_by_node:?}")]
+    #[display("node {node:?} input slot {input_slot} already occupied by {occupied_by_node:?}")]
     NodeInputSlotAlreadyOccupied {
         node: InternedRenderLabel,
         input_slot: usize,

crates/bevy_render/src/render_graph/node.rs

@@ -15,8 +15,8 @@ use bevy_ecs::{
 };
 use bevy_utils::all_tuples_with_size;
 use core::fmt::Debug;
+use derive_more::derive::{Display, Error, From};
 use downcast_rs::{impl_downcast, Downcast};
-use thiserror::Error;
 
 pub use bevy_render_macros::RenderLabel;
 
@@ -90,16 +90,16 @@ pub trait Node: Downcast + Send + Sync + 'static {
 
 impl_downcast!(Node);
 
-#[derive(Error, Debug, Eq, PartialEq)]
+#[derive(Error, Display, Debug, Eq, PartialEq, From)]
 pub enum NodeRunError {
-    #[error("encountered an input slot error")]
-    InputSlotError(#[from] InputSlotError),
-    #[error("encountered an output slot error")]
-    OutputSlotError(#[from] OutputSlotError),
-    #[error("encountered an error when running a sub-graph")]
-    RunSubGraphError(#[from] RunSubGraphError),
-    #[error("encountered an error when executing draw command")]
-    DrawError(#[from] DrawError),
+    #[display("encountered an input slot error")]
+    InputSlotError(InputSlotError),
+    #[display("encountered an output slot error")]
+    OutputSlotError(OutputSlotError),
+    #[display("encountered an error when running a sub-graph")]
+    RunSubGraphError(RunSubGraphError),
+    #[display("encountered an error when executing draw command")]
+    DrawError(DrawError),
 }
 
 /// A collection of input and output [`Edges`](Edge) for a [`Node`].