Merge remote-tracking branch 'origin/main' into color-externals

Author: Alice Cecile

crates/bevy_color/src/color.rs

@@ -40,11 +40,191 @@ impl Color {
     pub fn linear(&self) -> LinearRgba {
         (*self).into()
     }
+
+    /// Creates a new [`Color`] object storing a [`Srgba`] color.
+    pub const fn srgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
+        Self::Srgba(Srgba {
+            red,
+            green,
+            blue,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Srgba`] color with an alpha of 1.0.
+    pub const fn srgb(red: f32, green: f32, blue: f32) -> Self {
+        Self::Srgba(Srgba {
+            red,
+            green,
+            blue,
+            alpha: 1.0,
+        })
+    }
+
+    /// Createsa new [`Color`] object storing a [`LinearRgba`] color.
+    pub const fn linear_rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
+        Self::LinearRgba(LinearRgba {
+            red,
+            green,
+            blue,
+            alpha,
+        })
+    }
+
+    /// a new [`Color`] object storing a [`LinearRgba`] color with an alpha of 1.0.
+    pub const fn linear_rgb(red: f32, green: f32, blue: f32) -> Self {
+        Self::LinearRgba(LinearRgba {
+            red,
+            green,
+            blue,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hsla`] color.
+    pub const fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Self {
+        Self::Hsla(Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hsla`] color with an alpha of 1.0.
+    pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Self {
+        Self::Hsla(Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hsva`] color.
+    pub const fn hsva(hue: f32, saturation: f32, value: f32, alpha: f32) -> Self {
+        Self::Hsva(Hsva {
+            hue,
+            saturation,
+            value,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hsva`] color with an alpha of 1.0.
+    pub const fn hsv(hue: f32, saturation: f32, value: f32) -> Self {
+        Self::Hsva(Hsva {
+            hue,
+            saturation,
+            value,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hwba`] color.
+    pub const fn hwba(hue: f32, whiteness: f32, blackness: f32, alpha: f32) -> Self {
+        Self::Hwba(Hwba {
+            hue,
+            whiteness,
+            blackness,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Hwba`] color with an alpha of 1.0.
+    pub const fn hwb(hue: f32, whiteness: f32, blackness: f32) -> Self {
+        Self::Hwba(Hwba {
+            hue,
+            whiteness,
+            blackness,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Laba`] color.
+    pub const fn laba(lightness: f32, a: f32, b: f32, alpha: f32) -> Self {
+        Self::Laba(Laba {
+            lightness,
+            a,
+            b,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Laba`] color with an alpha of 1.0.
+    pub const fn lab(lightness: f32, a: f32, b: f32) -> Self {
+        Self::Laba(Laba {
+            lightness,
+            a,
+            b,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Lcha`] color.
+    pub const fn lcha(lightness: f32, chroma: f32, hue: f32, alpha: f32) -> Self {
+        Self::Lcha(Lcha {
+            lightness,
+            chroma,
+            hue,
+            alpha,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Lcha`] color with an alpha of 1.0.
+    pub const fn lch(lightness: f32, chroma: f32, hue: f32) -> Self {
+        Self::Lcha(Lcha {
+            lightness,
+            chroma,
+            hue,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Oklaba`] color.
+    pub const fn oklaba(l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        Self::Oklaba(Oklaba { l, a, b, alpha })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Oklaba`] color with an alpha of 1.0.
+    pub const fn oklab(l: f32, a: f32, b: f32) -> Self {
+        Self::Oklaba(Oklaba {
+            l,
+            a,
+            b,
+            alpha: 1.0,
+        })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Xyza`] color.
+    pub const fn xyza(x: f32, y: f32, z: f32, alpha: f32) -> Self {
+        Self::Xyza(Xyza { x, y, z, alpha })
+    }
+
+    /// Creates a new [`Color`] object storing a [`Xyza`] color with an alpha of 1.0.
+    pub const fn xyz(x: f32, y: f32, z: f32) -> Self {
+        Self::Xyza(Xyza {
+            x,
+            y,
+            z,
+            alpha: 1.0,
+        })
+    }
+
+    /// A fully white [`Color::LinearRgba`] color with an alpha of 1.0.
+    pub const WHITE: Self = Self::linear_rgb(1.0, 1.0, 1.0);
+
+    /// A fully black [`Color::LinearRgba`] color with an alpha of 1.0.
+    pub const BLACK: Self = Self::linear_rgb(0., 0., 0.);
+
+    /// A fully transparent [`Color::LinearRgba`] color.
+    pub const TRANSPARENT: Self = Self::linear_rgba(0., 0., 0., 0.);
 }
 
 impl Default for Color {
+    /// A fully white [`Color::LinearRgba`] color with an alpha of 1.0.
     fn default() -> Self {
-        Self::Srgba(Srgba::WHITE)
+        Color::WHITE
     }
 }
 

crates/bevy_ecs/src/reflect/entity_commands.rs

@@ -194,7 +194,7 @@ fn insert_reflect(
         .expect("component should represent a type.");
     let type_path = type_info.type_path();
     let Some(mut entity) = world.get_entity_mut(entity) else {
-        panic!("error[B0003]: Could not insert a reflected component (of type {type_path}) for entity {entity:?} because it doesn't exist in this World.");
+        panic!("error[B0003]: Could not insert a reflected component (of type {type_path}) for entity {entity:?} because it doesn't exist in this World. See: https://bevyengine.org/learn/errors/#b0003");
     };
     let Some(type_registration) = type_registry.get_with_type_path(type_path) else {
         panic!("Could not get type registration (for component type {type_path}) because it doesn't exist in the TypeRegistry.");

crates/bevy_ecs/src/system/commands/mod.rs

@@ -1072,7 +1072,7 @@ fn insert<T: Bundle>(bundle: T) -> impl EntityCommand {
         if let Some(mut entity) = world.get_entity_mut(entity) {
             entity.insert(bundle);
         } else {
-            panic!("error[B0003]: Could not insert a bundle (of type `{}`) for entity {:?} because it doesn't exist in this World.", std::any::type_name::<T>(), entity);
+            panic!("error[B0003]: Could not insert a bundle (of type `{}`) for entity {:?} because it doesn't exist in this World. See: https://bevyengine.org/learn/errors/#b0003", std::any::type_name::<T>(), entity);
         }
     }
 }

crates/bevy_ecs/src/system/system_param.rs

@@ -249,7 +249,7 @@ fn assert_component_access_compatibility(
         .map(|component_id| world.components.get_info(component_id).unwrap().name())
         .collect::<Vec<&str>>();
     let accesses = conflicting_components.join(", ");
-    panic!("error[B0001]: Query<{query_type}, {filter_type}> in system {system_name} accesses component(s) {accesses} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`.");
+    panic!("error[B0001]: Query<{query_type}, {filter_type}> in system {system_name} accesses component(s) {accesses} in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`. See: https://bevyengine.org/learn/errors/#b0001");
 }
 
 /// A collection of potentially conflicting [`SystemParam`]s allowed by disjoint access.
@@ -446,7 +446,7 @@ unsafe impl<'a, T: Resource> SystemParam for Res<'a, T> {
         let combined_access = system_meta.component_access_set.combined_access();
         assert!(
             !combined_access.has_write(component_id),
-            "error[B0002]: Res<{}> in system {} conflicts with a previous ResMut<{0}> access. Consider removing the duplicate access.",
+            "error[B0002]: Res<{}> in system {} conflicts with a previous ResMut<{0}> access. Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
             std::any::type_name::<T>(),
             system_meta.name,
         );
@@ -536,11 +536,11 @@ unsafe impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
         let combined_access = system_meta.component_access_set.combined_access();
         if combined_access.has_write(component_id) {
             panic!(
-                "error[B0002]: ResMut<{}> in system {} conflicts with a previous ResMut<{0}> access. Consider removing the duplicate access.",
+                "error[B0002]: ResMut<{}> in system {} conflicts with a previous ResMut<{0}> access. Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
                 std::any::type_name::<T>(), system_meta.name);
         } else if combined_access.has_read(component_id) {
             panic!(
-                "error[B0002]: ResMut<{}> in system {} conflicts with a previous Res<{0}> access. Consider removing the duplicate access.",
+                "error[B0002]: ResMut<{}> in system {} conflicts with a previous Res<{0}> access. Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
                 std::any::type_name::<T>(), system_meta.name);
         }
         system_meta
@@ -1031,7 +1031,7 @@ unsafe impl<'a, T: 'static> SystemParam for NonSend<'a, T> {
         let combined_access = system_meta.component_access_set.combined_access();
         assert!(
             !combined_access.has_write(component_id),
-            "error[B0002]: NonSend<{}> in system {} conflicts with a previous mutable resource access ({0}). Consider removing the duplicate access.",
+            "error[B0002]: NonSend<{}> in system {} conflicts with a previous mutable resource access ({0}). Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
             std::any::type_name::<T>(),
             system_meta.name,
         );
@@ -1118,11 +1118,11 @@ unsafe impl<'a, T: 'static> SystemParam for NonSendMut<'a, T> {
         let combined_access = system_meta.component_access_set.combined_access();
         if combined_access.has_write(component_id) {
             panic!(
-                "error[B0002]: NonSendMut<{}> in system {} conflicts with a previous mutable resource access ({0}). Consider removing the duplicate access.",
+                "error[B0002]: NonSendMut<{}> in system {} conflicts with a previous mutable resource access ({0}). Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
                 std::any::type_name::<T>(), system_meta.name);
         } else if combined_access.has_read(component_id) {
             panic!(
-                "error[B0002]: NonSendMut<{}> in system {} conflicts with a previous immutable resource access ({0}). Consider removing the duplicate access.",
+                "error[B0002]: NonSendMut<{}> in system {} conflicts with a previous immutable resource access ({0}). Consider removing the duplicate access. See: https://bevyengine.org/learn/errors/#b0002",
                 std::any::type_name::<T>(), system_meta.name);
         }
         system_meta

crates/bevy_ecs/src/world/mod.rs

@@ -887,7 +887,7 @@ impl World {
             entity.despawn();
             true
         } else {
-            warn!("error[B0003]: Could not despawn entity {:?} because it doesn't exist in this World.", entity);
+            warn!("error[B0003]: Could not despawn entity {:?} because it doesn't exist in this World. See: https://bevyengine.org/learn/errors/#b0003", entity);
             false
         }
     }

crates/bevy_text/src/glyph_brush.rs

@@ -115,7 +115,9 @@ impl GlyphBrush {
                 if !text_settings.allow_dynamic_font_size
                     && font_atlas_set.len() > text_settings.soft_max_font_atlases.get()
                 {
-                    warn_once!("warning[B0005]: Number of font atlases has exceeded the maximum of {}. Performance and memory usage may suffer.", text_settings.soft_max_font_atlases.get());
+                    warn_once!(
+                        "warning[B0005]: Number of font atlases has exceeded the maximum of {}. Performance and memory usage may suffer. See: https://bevyengine.org/learn/errors/#b0005",
+                        text_settings.soft_max_font_atlases.get());
                 }
 
                 let texture_atlas = texture_atlases.get(&atlas_info.texture_atlas).unwrap();