Docs

Author: Zeophlite

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -846,6 +846,12 @@ pub fn prepare_core_3d_depth_textures(
     }
 }
 
+/// A material can specify [`MaterialProperties:reads_view_transmission_texture`] to read from [`ViewTransmissionTexture`].
+///
+/// This allows taking color output from the [`Opaque3d`] pass as an input, (for screen-space transmission) but requires
+/// rendering to take place in a separate [`Transmissive3d`] pass.
+///
+/// [MaterialProperties]: bevy_material::material::MaterialProperties
 #[derive(Component)]
 pub struct ViewTransmissionTexture {
     pub texture: Texture,

crates/bevy_material/src/material.rs

@@ -22,7 +22,7 @@ use smallvec::SmallVec;
 
 pub const MATERIAL_BIND_GROUP_INDEX: usize = 3;
 
-/// Render pipeline data for a given [`Material`].
+/// Render pipeline data for a given material.
 #[derive(Resource, Clone)]
 pub struct MaterialPipeline {
     pub mesh_pipeline: MeshPipeline,
@@ -114,7 +114,7 @@ impl Default for ErasedMaterialKey {
     }
 }
 
-/// Common [`Material`] properties, calculated for a specific material instance.
+/// Common material properties, calculated for a specific material instance.
 #[derive(Default)]
 pub struct MaterialProperties {
     /// Is this material should be rendered by the deferred renderer when.
@@ -124,17 +124,16 @@ pub struct MaterialProperties {
     pub alpha_mode: AlphaMode,
     /// The bits in the [`MeshPipelineKey`] for this material.
     ///
-    /// These are precalculated so that we can just "or" them together in
-    /// [`queue_material_meshes`].
+    /// These are precalculated so that we can just "or" them together.
     pub mesh_pipeline_key_bits: MeshPipelineKey,
     /// Add a bias to the view depth of the mesh which can be used to force a specific render order
     /// for meshes with equal depth, to avoid z-fighting.
     /// The bias is in depth-texture units so large values may be needed to overcome small depth differences.
     pub depth_bias: f32,
-    /// Whether the material would like to read from [`ViewTransmissionTexture`](bevy_core_pipeline::core_3d::ViewTransmissionTexture).
+    /// Whether the material would like to read from a view transmission texture
     ///
-    /// This allows taking color output from the [`Opaque3d`] pass as an input, (for screen-space transmission) but requires
-    /// rendering to take place in a separate [`Transmissive3d`] pass.
+    /// This allows taking color output from the opaque 3d pass as an input, (for screen-space transmission) but requires
+    /// rendering to take place in a separate transmissive 3d pass.
     pub reads_view_transmission_texture: bool,
     pub render_phase_type: RenderPhaseType,
     pub material_layout: Option<BindGroupLayoutDescriptor>,

crates/bevy_material/src/render_phase/draw.rs

@@ -1,6 +1,6 @@
 use core::{fmt::Debug, hash::Hash};
 
 // TODO: make this generic?
-/// An identifier for a [`Draw`] function stored in [`DrawFunctions`].
+/// An identifier for a draw functions stored.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
 pub struct DrawFunctionId(pub u32);

crates/bevy_pbr/src/material.rs

@@ -72,6 +72,10 @@ pub use bevy_material::material::*;
 /// 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.
 ///
+/// Doc refs [MaterialPipline], [`MaterialProperties`]
+///
+/// [MaterialPipeline]: bevy_material::material::MaterialPipeline
+///
 /// # Example
 ///
 /// Here is a simple [`Material`] implementation. The [`AsBindGroup`] derive has many features. To see what else is available,
@@ -1152,6 +1156,8 @@ pub fn specialize_material_meshes(
 
 /// For each view, iterates over all the meshes visible from that view and adds
 /// them to [`BinnedRenderPhase`]s or [`SortedRenderPhase`]s as appropriate.
+///
+/// Uses data from [`RenderMeshQueueData`] in order to place entities that contain meshes in the right batch.
 pub fn queue_material_meshes(
     render_materials: Res<ErasedRenderAssets<PreparedMaterial>>,
     render_mesh_instances: Res<RenderMeshInstances>,

crates/bevy_pbr/src/pbr_material.rs

@@ -27,6 +27,11 @@ pub enum UvChannel {
 /// <https://google.github.io/filament/notes/material_properties.html>.
 ///
 /// May be created directly from a [`Color`] or an [`Image`].
+///
+/// When a [`Lightmap`] is assigned to an entity that contains a [`Mesh3d`](bevy_mesh::Mesh3d) and a
+/// [`MeshMaterial3d<StandardMaterial>`](crate::StandardMaterial), if the mesh
+/// has a second UV layer ([`ATTRIBUTE_UV_1`](bevy_mesh::Mesh::ATTRIBUTE_UV_1)),
+/// then the lightmap will render using those UVs.
 #[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
 #[bind_group_data(StandardMaterialKey)]
 #[data(0, StandardMaterialUniform, binding_array(10))]

crates/bevy_pbr/src/render/mesh.rs

@@ -617,6 +617,8 @@ impl RenderMeshInstanceGpuQueue {
 impl RenderMeshInstanceGpuBuilder {
     /// Flushes this mesh instance to the [`RenderMeshInstanceGpu`] and
     /// [`MeshInputUniform`] tables, replacing the existing entry if applicable.
+    ///
+    /// Provides the mesh instance id for [`RenderMeshInstanceShared:for_gpu_building`]
     fn update(
         mut self,
         entity: MainEntity,

crates/bevy_render/src/lightmap/mod.rs

@@ -35,11 +35,6 @@ pub const LIGHTMAPS_PER_SLAB: usize = 4;
 
 /// A component that applies baked indirect diffuse global illumination from a
 /// lightmap.
-///
-/// When assigned to an entity that contains a [`Mesh3d`](bevy_mesh::Mesh3d) and a
-/// [`MeshMaterial3d<StandardMaterial>`](crate::StandardMaterial), if the mesh
-/// has a second UV layer ([`ATTRIBUTE_UV_1`](bevy_mesh::Mesh::ATTRIBUTE_UV_1)),
-/// then the lightmap will render using those UVs.
 #[derive(Component, Clone, Reflect)]
 #[reflect(Component, Default, Clone)]
 pub struct Lightmap {

crates/bevy_render/src/mesh/allocator.rs

@@ -52,6 +52,17 @@ pub struct MeshAllocatorPlugin;
 /// The [`MeshAllocatorSettings`] allows you to tune the behavior of the
 /// allocator for better performance with your application. Most applications
 /// won't need to change the settings from their default values.
+///
+/// Multiple meshes can be packed into a single vertex buffer.
+///
+/// [`MeshUniform:first_vertex_index`] stores the offset of the first vertex in
+/// this mesh in that buffer.
+///
+/// [`MeshInputUniform:first_vertex_index`] stores the offset of the first vertex in
+/// this mesh in that buffer.
+///
+/// [`MeshInputUniform:first_index_index`] stores the offset of the first index in
+/// this mesh in that buffer.
 #[derive(Resource)]
 pub struct MeshAllocator {
     /// Holds all buffers and allocators.

crates/bevy_render/src/mesh/render.rs

@@ -53,7 +53,7 @@ pub struct MeshUniform {
     /// The index of this mesh's first vertex in the vertex buffer.
     ///
     /// Multiple meshes can be packed into a single vertex buffer (see
-    /// [`MeshAllocator`]). This value stores the offset of the first vertex in
+    /// mesh allocator). This value stores the offset of the first vertex in
     /// this mesh in that buffer.
     pub first_vertex_index: u32,
     /// The current skin index, or `u32::MAX` if there's no skin.
@@ -100,13 +100,13 @@ pub struct MeshInputUniform {
     /// The index of this mesh's first vertex in the vertex buffer.
     ///
     /// Multiple meshes can be packed into a single vertex buffer (see
-    /// [`MeshAllocator`]). This value stores the offset of the first vertex in
+    /// mesh allocator). This value stores the offset of the first vertex in
     /// this mesh in that buffer.
     pub first_vertex_index: u32,
     /// The index of this mesh's first index in the index buffer, if any.
     ///
     /// Multiple meshes can be packed into a single index buffer (see
-    /// [`MeshAllocator`]). This value stores the offset of the first index in
+    /// mesh allocator). This value stores the offset of the first index in
     /// this mesh in that buffer.
     ///
     /// If this mesh isn't indexed, this value is ignored.
@@ -306,7 +306,6 @@ pub struct RenderMeshInstanceShared {
 
 impl RenderMeshInstanceShared {
     /// A gpu builder will provide the mesh instance id
-    /// during [`RenderMeshInstanceGpuBuilder::update`].
     pub fn for_gpu_building(
         previous_transform: Option<&PreviousGlobalTransform>,
         mesh: &Mesh3d,
@@ -326,7 +325,7 @@ impl RenderMeshInstanceShared {
         )
     }
 
-    /// The cpu builder does not have an equivalent [`RenderMeshInstanceGpuBuilder::update`].
+    /// The cpu builder does not have an equivalent ?
     pub fn for_cpu_building(
         previous_transform: Option<&PreviousGlobalTransform>,
         mesh: &Mesh3d,
@@ -488,8 +487,7 @@ impl RenderMeshInstancesGpu {
     }
 }
 
-/// Data that [`crate::material::queue_material_meshes`] and similar systems
-/// need in order to place entities that contain meshes in the right batch.
+/// Data that systems need in order to place entities that contain meshes in the right batch.
 #[derive(Deref)]
 pub struct RenderMeshQueueData<'a> {
     /// General information about the mesh instance.

crates/bevy_render/src/render_phase/draw.rs

@@ -16,6 +16,8 @@ use variadics_please::all_tuples;
 
 /// A draw function used to draw [`PhaseItem`]s.
 ///
+/// Identified by a [`DrawFunctionId`], stored in [`DrawFunctions`]
+///
 /// The draw function can retrieve and query the required ECS data from the render world.
 ///
 /// This trait can either be implemented directly or implicitly composed out of multiple modular
@@ -106,7 +108,7 @@ impl<P: PhaseItem> DrawFunctionsInternal<P> {
     }
 }
 
-/// Stores all draw functions for the [`PhaseItem`] type hidden behind a reader-writer lock.
+/// Stores all [`Draw`] functions for the [`PhaseItem`] type hidden behind a reader-writer lock.
 ///
 /// To access them the [`DrawFunctions::read`] and [`DrawFunctions::write`] methods are used.
 #[derive(Resource)]