Fix ci doctests for bevy_render_2d

Author: hukasu

crates/bevy_gizmos/src/lib.rs

@@ -148,7 +148,7 @@ const LINE_JOINT_SHADER_HANDLE: Handle<Shader> =
 
 /// A [`Plugin`] that provides an immediate mode drawing api for visual debugging.
 ///
-/// Requires to be loaded after [`PbrPlugin`](bevy_pbr::PbrPlugin) or [`SpritePlugin`](bevy_render_2d::SpritePlugin).
+/// Requires to be loaded after [`PbrPlugin`](bevy_pbr::PbrPlugin) or [`Mesh2dRenderPlugin`](bevy_render_2d::mesh_pipeline::Mesh2dRenderPlugin).
 #[derive(Default)]
 pub struct GizmoPlugin;
 

crates/bevy_render_2d/Cargo.toml

@@ -28,6 +28,10 @@ derive_more = { version = "1", default-features = false, features = ["from"] }
 nonmax = "0.5"
 tracing = { version = "0.1", default-features = false, features = ["std"] }
 
+[dev-dependencies]
+# used on doc tests
+bevy_color = { path = "../bevy_color", version = "0.16.0-dev" }
+
 [lints]
 workspace = true
 

crates/bevy_render_2d/src/material/alpha_mode.rs

@@ -1,7 +1,7 @@
 use bevy_reflect::{prelude::ReflectDefault, Reflect};
 
 /// Sets how a 2d material's base color alpha channel is used for transparency.
-/// Currently, this only works with [`Mesh2d`]. Sprites are always transparent.
+/// Currently, this only works with [`Mesh2d`](bevy_render::mesh::Mesh2d). Sprites are always transparent.
 ///
 /// This is very similar to [`AlphaMode`](bevy_render::alpha::AlphaMode) but this only applies to 2d meshes.
 /// We use a separate type because 2d doesn't support all the transparency modes that 3d does.

crates/bevy_render_2d/src/material/components.rs

@@ -6,20 +6,32 @@ use derive_more::derive::From;
 
 use super::Material2d;
 
-/// A [material](Material2d) used for rendering a [`Mesh2d`].
+/// A [material](Material2d) used for rendering a [`Mesh2d`](bevy_render::mesh::Mesh2d).
 ///
 /// See [`Material2d`] for general information about 2D materials and how to implement your own materials.
 ///
 /// # Example
 ///
 /// ```
-/// # use bevy_sprite::{ColorMaterial, MeshMaterial2d};
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_render::mesh::{Mesh, Mesh2d};
-/// # use bevy_color::palettes::basic::RED;
-/// # use bevy_asset::Assets;
+/// # use bevy_render::{mesh::{Mesh, Mesh2d}, render_resource::AsBindGroup};
+/// # use bevy_render_2d::material::{MeshMaterial2d, Material2d, AlphaMode2d};
+/// # use bevy_color::{Color, palettes::basic::RED};
+/// # use bevy_asset::{Asset, Assets};
 /// # use bevy_math::primitives::Circle;
+/// # use bevy_reflect::Reflect;
 /// #
+/// # // Defining locally so that there is no need to depend on `bevy_sprite`
+/// # #[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+/// # struct ColorMaterial {}
+/// # impl ColorMaterial {
+/// #   pub fn from_color(_color: impl Into<Color>) -> Self { Self {} }
+/// # }
+/// # impl Material2d for ColorMaterial {
+/// #     fn alpha_mode(&self) -> AlphaMode2d {
+/// #         AlphaMode2d::Opaque
+/// #     }
+/// # }
 /// // Spawn an entity with a mesh using `ColorMaterial`.
 /// fn setup(
 ///     mut commands: Commands,

crates/bevy_render_2d/src/material/pipeline/prepared_asset.rs

@@ -17,6 +17,7 @@ use super::{properties::Material2dProperties, DrawMaterial2d, Material2dPipeline
 
 /// Data prepared for a [`Material2d`] instance.
 pub struct PreparedMaterial2d<T: Material2d> {
+    #[expect(dead_code, reason = "`dead_code` under investigation")]
     pub bindings: BindingResources,
     pub bind_group: BindGroup,
     pub key: T::Data,

crates/bevy_render_2d/src/material/pipeline/properties.rs

@@ -2,7 +2,7 @@ use bevy_render::render_phase::DrawFunctionId;
 
 use crate::{material::AlphaMode2d, mesh_pipeline::pipeline::Mesh2dPipelineKey};
 
-/// Common [`Material2d`] properties, calculated for a specific material instance.
+/// Common [`Material2d`](super::Material2d) properties, calculated for a specific material instance.
 pub struct Material2dProperties {
     /// The [`AlphaMode2d`] of this material.
     pub alpha_mode: AlphaMode2d,
@@ -13,7 +13,7 @@ pub struct Material2dProperties {
     /// The bits in the [`Mesh2dPipelineKey`] for this material.
     ///
     /// These are precalculated so that we can just "or" them together in
-    /// [`queue_material2d_meshes`].
+    /// [`queue_material2d_meshes`](crate::material::queue_material2d_meshes).
     pub mesh_pipeline_key_bits: Mesh2dPipelineKey,
     pub draw_function_id: DrawFunctionId,
 }

crates/bevy_render_2d/src/material/traits.rs

@@ -8,9 +8,10 @@ use bevy_render::{
 
 use super::{AlphaMode2d, Material2dKey};
 
-/// Materials are used alongside [`Material2dPlugin`], [`Mesh2d`], and [`MeshMaterial2d`]
+/// Materials are used alongside [`Material2dPlugin`](super::Material2dPlugin),
+/// [`Mesh2d`](bevy_render::mesh::Mesh2d), and [`MeshMaterial2d`](super::MeshMaterial2d)
 /// to spawn entities that are rendered with a specific [`Material2d`] type. They serve as an easy to use high level
-/// way to render [`Mesh2d`] entities with custom shader logic.
+/// way to render [`Mesh2d`](bevy_render::mesh::Mesh2d) entities with custom shader logic.
 ///
 /// Materials must implement [`AsBindGroup`] to define how data will be transferred to the GPU and bound in shaders.
 /// [`AsBindGroup`] can be derived, which makes generating bindings straightforward. See the [`AsBindGroup`] docs for details.
@@ -21,13 +22,12 @@ use super::{AlphaMode2d, Material2dKey};
 /// check out the [`AsBindGroup`] documentation.
 ///
 /// ```
-/// # use bevy_sprite::{Material2d, MeshMaterial2d};
+/// # use bevy_render_2d::material::{Material2d, MeshMaterial2d};
 /// # use bevy_ecs::prelude::*;
 /// # use bevy_image::Image;
 /// # use bevy_reflect::TypePath;
 /// # use bevy_render::{mesh::{Mesh, Mesh2d}, render_resource::{AsBindGroup, ShaderRef}};
-/// # use bevy_color::LinearRgba;
-/// # use bevy_color::palettes::basic::RED;
+/// # use bevy_color::{LinearRgba, palettes::basic::RED};
 /// # use bevy_asset::{Handle, AssetServer, Assets, Asset};
 /// # use bevy_math::primitives::Circle;
 /// #