fixed docs, examples, CI

Author: kurtkuehnert

crates/bevy_gpu/src/gpu_resource/bind_group.rs

@@ -9,11 +9,11 @@ gpu_resource_wrapper!(ErasedBindGroup, wgpu::BindGroup);
 pub struct BindGroupId(Uuid);
 
 /// Bind groups are responsible for binding render resources (e.g. buffers, textures, samplers)
-/// to a [`TrackedRenderPass`](crate::render_phase::TrackedRenderPass).
+/// to a render pass.
 /// This makes them accessible in the pipeline (shaders) as uniforms.
 ///
 /// May be converted from and dereferences to a wgpu [`BindGroup`](wgpu::BindGroup).
-/// Can be created via [`GPUDevice::create_bind_group`](crate::renderer::GpuDevice::create_bind_group).
+/// Can be created via [`GPUDevice::create_bind_group`](crate::GpuDevice::create_bind_group).
 #[derive(Clone, Debug)]
 pub struct BindGroup {
     id: BindGroupId,

crates/bevy_gpu/src/gpu_resource/buffer_vec.rs

@@ -12,17 +12,17 @@ use wgpu::BufferUsages;
 /// Index, vertex, and instance-rate vertex buffers have no alignment nor padding requirements and
 /// so this helper type is a good choice for them.
 ///
-/// The contained data is stored in system RAM. Calling [`reserve`](crate::render_resource::BufferVec::reserve)
-/// allocates VRAM from the [`GPUDevice`](crate::renderer::GpuDevice).
-/// [`write_buffer`](crate::render_resource::BufferVec::write_buffer) queues copying of the data
+/// The contained data is stored in system RAM. Calling [`reserve`](BufferVec::reserve)
+/// allocates VRAM from the [`GpuDevice`].
+/// [`write_buffer`](BufferVec::write_buffer) queues copying of the data
 /// from system RAM to VRAM.
 ///
 /// Other options for storing GPU-accessible data are:
-/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
-/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
-/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
-/// * [`BufferVec`](crate::render_resource::BufferVec)
-/// * [`Texture`](crate::render_resource::Texture)
+/// * [`DynamicStorageBuffer`](crate::gpu_resource::DynamicStorageBuffer)
+/// * [`UniformBuffer`](crate::gpu_resource::UniformBuffer)
+/// * [`DynamicUniformBuffer`](crate::gpu_resource::DynamicUniformBuffer)
+/// * [`BufferVec`](crate::gpu_resource::BufferVec)
+/// * [`Texture`](crate::gpu_resource::Texture)
 pub struct BufferVec<T: Pod> {
     values: Vec<T>,
     buffer: Option<Buffer>,
@@ -86,17 +86,17 @@ impl<T: Pod> BufferVec<T> {
         self.label.as_deref()
     }
 
-    /// Creates a [`Buffer`](crate::render_resource::Buffer) on the [`GPUDevice`](crate::renderer::GpuDevice) with size
-    /// at least `std::mem::size_of::<T>() * capacity`, unless a such a buffer already exists.
+    /// Creates a [`Buffer`] on the [`GpuDevice`] with size at least
+    /// `std::mem::size_of::<T>() * capacity`, unless a such a buffer already exists.
     ///
-    /// If a [`Buffer`](crate::render_resource::Buffer) exists, but is too small, references to it will be discarded,
-    /// and a new [`Buffer`](crate::render_resource::Buffer) will be created. Any previously created [`Buffer`](crate::render_resource::Buffer)s
-    /// that are no longer referenced will be deleted by the [`GPUDevice`](crate::renderer::GpuDevice)
+    /// If a [`Buffer`] exists, but is too small, references to it will be discarded,
+    /// and a new [`Buffer`] will be created. Any previously created [`Buffer`]s
+    /// that are no longer referenced will be deleted by the [`GpuDevice`]
     /// once it is done using them (typically 1-2 frames).
     ///
-    /// In addition to any [`BufferUsages`](crate::render_resource::BufferUsages) provided when
-    /// the `BufferVec` was created, the buffer on the [`GPUDevice`](crate::renderer::GpuDevice)
-    /// is marked as [`BufferUsages::COPY_DST`](crate::render_resource::BufferUsages).
+    /// In addition to any [`BufferUsages`] provided when
+    /// the `BufferVec` was created, the buffer on the [`GpuDevice`]
+    /// is marked as [`BufferUsages::COPY_DST`].
     pub fn reserve(&mut self, capacity: usize, gpu_device: &GpuDevice) {
         if capacity > self.capacity || self.label_changed {
             self.capacity = capacity;
@@ -111,10 +111,10 @@ impl<T: Pod> BufferVec<T> {
         }
     }
 
-    /// Queues writing of data from system RAM to VRAM using the [`GPUDevice`](crate::renderer::GpuDevice)
-    /// and the provided [`GPUQueue`](crate::renderer::GpuQueue).
+    /// Queues writing of data from system RAM to VRAM using the [`GpuDevice`]
+    /// and the provided [`GpuQueue`].
     ///
-    /// Before queuing the write, a [`reserve`](crate::render_resource::BufferVec::reserve) operation
+    /// Before queuing the write, a [`BufferVec::reserve`] operation
     /// is executed.
     pub fn write_buffer(&mut self, gpu_device: &GpuDevice, gpu_queue: &GpuQueue) {
         if self.values.is_empty() {

crates/bevy_gpu/src/gpu_resource/pipeline.rs

@@ -16,7 +16,7 @@ gpu_resource_wrapper!(ErasedRenderPipeline, wgpu::RenderPipeline);
 /// A [`RenderPipeline`] represents a graphics pipeline and its stages (shaders), bindings and vertex buffers.
 ///
 /// May be converted from and dereferences to a wgpu [`RenderPipeline`](wgpu::RenderPipeline).
-/// Can be created via [`GPUDevice::create_render_pipeline`](crate::renderer::GpuDevice::create_render_pipeline).
+/// Can be created via [`GpuDevice::create_render_pipeline`](crate::GpuDevice::create_render_pipeline).
 #[derive(Clone, Debug)]
 pub struct RenderPipeline {
     id: RenderPipelineId,
@@ -57,7 +57,7 @@ gpu_resource_wrapper!(ErasedComputePipeline, wgpu::ComputePipeline);
 /// A [`ComputePipeline`] represents a compute pipeline and its single shader stage.
 ///
 /// May be converted from and dereferences to a wgpu [`ComputePipeline`](wgpu::ComputePipeline).
-/// Can be created via [`GPUDevice::create_compute_pipeline`](crate::renderer::GpuDevice::create_compute_pipeline).
+/// Can be created via [`GpuDevice::create_compute_pipeline`](crate::GpuDevice::create_compute_pipeline).
 #[derive(Clone, Debug)]
 pub struct ComputePipeline {
     id: ComputePipelineId,

crates/bevy_gpu/src/gpu_resource/pipeline_cache.rs

@@ -324,13 +324,11 @@ impl LayoutCache {
 /// The cache stores existing render and compute pipelines allocated on the GPU, as well as
 /// pending creation. Pipelines inserted into the cache are identified by a unique ID, which
 /// can be used to retrieve the actual GPU object once it's ready. The creation of the GPU
-/// pipeline object is deferred to the [`RenderStage::Render`] stage, just before the render
+/// pipeline object is deferred to the render stage, just before the render
 /// graph starts being processed, as this requires access to the GPU.
 ///
 /// Note that the cache do not perform automatic deduplication of identical pipelines. It is
 /// up to the user not to insert the same pipeline twice to avoid wasting GPU resources.
-///
-/// [`RenderStage::Render`]: crate::RenderStage::Render
 #[derive(Resource)]
 pub struct PipelineCache {
     layout_cache: LayoutCache,
@@ -622,10 +620,8 @@ impl PipelineCache {
 
     /// Process the pipeline queue and create all pending pipelines if possible.
     ///
-    /// This is generally called automatically during the [`RenderStage::Render`] stage, but can
+    /// This is generally called automatically during the render stage, but can
     /// be called manually to force creation at a different time.
-    ///
-    /// [`RenderStage::Render`]: crate::RenderStage::Render
     pub fn process_queue(&mut self) {
         let waiting_pipelines = mem::take(&mut self.waiting_pipelines);
         let mut pipelines = mem::take(&mut self.pipelines);

crates/bevy_gpu/src/gpu_resource/storage_buffer.rs

@@ -14,16 +14,16 @@ use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferUsa
 ///
 /// Storage buffers can store runtime-sized arrays, but only if they are the last field in a structure.
 ///
-/// The contained data is stored in system RAM. [`write_buffer`](crate::render_resource::StorageBuffer::write_buffer) queues
+/// The contained data is stored in system RAM. [`write_buffer`](crate::gpu_resource::StorageBuffer::write_buffer) queues
 /// copying of the data from system RAM to VRAM. Storage buffers must conform to [std430 alignment/padding requirements], which
 /// is automatically enforced by this structure.
 ///
 /// Other options for storing GPU-accessible data are:
-/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
-/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
-/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
-/// * [`BufferVec`](crate::render_resource::BufferVec)
-/// * [`Texture`](crate::render_resource::Texture)
+/// * [`DynamicStorageBuffer`](crate::gpu_resource::DynamicStorageBuffer)
+/// * [`UniformBuffer`](crate::gpu_resource::UniformBuffer)
+/// * [`DynamicUniformBuffer`](crate::gpu_resource::DynamicUniformBuffer)
+/// * [`BufferVec`](crate::gpu_resource::BufferVec)
+/// * [`Texture`](crate::gpu_resource::Texture)
 ///
 /// [std430 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-storage
 pub struct StorageBuffer<T: ShaderType> {
@@ -100,8 +100,8 @@ impl<T: ShaderType + WriteInto> StorageBuffer<T> {
         self.label.as_deref()
     }
 
-    /// Queues writing of data from system RAM to VRAM using the [`GPUDevice`](crate::renderer::GpuDevice)
-    /// and the provided [`GPUQueue`](crate::renderer::GpuQueue).
+    /// Queues writing of data from system RAM to VRAM using the [`GpuDevice`]
+    /// and the provided [`GpuQueue`].
     ///
     /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
     /// allocated does not have enough capacity, a new GPU-side buffer is created.
@@ -129,20 +129,20 @@ impl<T: ShaderType + WriteInto> StorageBuffer<T> {
 /// Dynamic storage buffers can be made available to shaders in some combination of read/write mode, and can store large amounts
 /// of data. Note however that WebGL2 does not support storage buffers, so consider alternative options in this case. Dynamic
 /// storage buffers support multiple separate bindings at dynamic byte offsets and so have a
-/// [`push`](crate::render_resource::DynamicStorageBuffer::push) method.
+/// [`push`](crate::gpu_resource::DynamicStorageBuffer::push) method.
 ///
-/// The contained data is stored in system RAM. [`write_buffer`](crate::render_resource::DynamicStorageBuffer::write_buffer)
+/// The contained data is stored in system RAM. [`write_buffer`](crate::gpu_resource::DynamicStorageBuffer::write_buffer)
 /// queues copying of the data from system RAM to VRAM. The data within a storage buffer binding must conform to
 /// [std430 alignment/padding requirements]. `DynamicStorageBuffer` takes care of serialising the inner type to conform to
-/// these requirements. Each item [`push`](crate::render_resource::DynamicStorageBuffer::push)ed into this structure
+/// these requirements. Each item [`push`](crate::gpu_resource::DynamicStorageBuffer::push)ed into this structure
 /// will additionally be aligned to meet dynamic offset alignment requirements.
 ///
 /// Other options for storing GPU-accessible data are:
-/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
-/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
-/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
-/// * [`BufferVec`](crate::render_resource::BufferVec)
-/// * [`Texture`](crate::render_resource::Texture)
+/// * [`StorageBuffer`](crate::gpu_resource::StorageBuffer)
+/// * [`UniformBuffer`](crate::gpu_resource::UniformBuffer)
+/// * [`DynamicUniformBuffer`](crate::gpu_resource::DynamicUniformBuffer)
+/// * [`BufferVec`](crate::gpu_resource::BufferVec)
+/// * [`Texture`](crate::gpu_resource::Texture)
 ///
 /// [std430 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-storage
 pub struct DynamicStorageBuffer<T: ShaderType> {

crates/bevy_gpu/src/gpu_resource/texture.rs

@@ -12,7 +12,7 @@ gpu_resource_wrapper!(ErasedTexture, wgpu::Texture);
 /// A GPU-accessible texture.
 ///
 /// May be converted from and dereferences to a wgpu [`Texture`](wgpu::Texture).
-/// Can be created via [`GPUDevice::create_texture`](crate::renderer::GpuDevice::create_texture).
+/// Can be created via [`GpuDevice::create_texture`](crate::GpuDevice::create_texture).
 #[derive(Clone, Debug)]
 pub struct Texture {
     id: TextureId,
@@ -144,7 +144,7 @@ gpu_resource_wrapper!(ErasedSampler, wgpu::Sampler);
 /// They define image filters (including anisotropy) and address (wrapping) modes, among other things.
 ///
 /// May be converted from and dereferences to a wgpu [`Sampler`](wgpu::Sampler).
-/// Can be created via [`GPUDevice::create_sampler`](crate::renderer::GpuDevice::create_sampler).
+/// Can be created via [`GpuDevice::create_sampler`](crate::GpuDevice::create_sampler).
 #[derive(Clone, Debug)]
 pub struct Sampler {
     id: SamplerId,

crates/bevy_gpu/src/gpu_resource/uniform_buffer.rs

@@ -11,17 +11,17 @@ use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferUsa
 /// parameters that are constant during shader execution, and are best used for data that is relatively small in size as they are
 /// only guaranteed to support up to 16kB per binding.
 ///
-/// The contained data is stored in system RAM. [`write_buffer`](crate::render_resource::UniformBuffer::write_buffer) queues
+/// The contained data is stored in system RAM. [`write_buffer`](crate::gpu_resource::UniformBuffer::write_buffer) queues
 /// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
 /// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
 /// (vectors), or structures with fields that are vectors.
 ///
 /// Other options for storing GPU-accessible data are:
-/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
-/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
-/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
-/// * [`BufferVec`](crate::render_resource::BufferVec)
-/// * [`Texture`](crate::render_resource::Texture)
+/// * [`DynamicUniformBuffer`](crate::gpu_resource::DynamicUniformBuffer)
+/// * [`StorageBuffer`](crate::gpu_resource::StorageBuffer)
+/// * [`DynamicStorageBuffer`](crate::gpu_resource::DynamicStorageBuffer)
+/// * [`BufferVec`](crate::gpu_resource::BufferVec)
+/// * [`Texture`](crate::gpu_resource::Texture)
 ///
 /// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
 pub struct UniformBuffer<T: ShaderType> {
@@ -96,8 +96,8 @@ impl<T: ShaderType + WriteInto> UniformBuffer<T> {
         self.label.as_deref()
     }
 
-    /// Queues writing of data from system RAM to VRAM using the [`GPUDevice`](crate::renderer::GpuDevice)
-    /// and the provided [`GPUQueue`](crate::renderer::GpuQueue), if a GPU-side backing buffer already exists.
+    /// Queues writing of data from system RAM to VRAM using the [`GpuDevice`]
+    /// and the provided [`GpuQueue`], if a GPU-side backing buffer already exists.
     ///
     /// If a GPU-side buffer does not already exist for this data, such a buffer is initialized with currently
     /// available data.
@@ -123,17 +123,17 @@ impl<T: ShaderType + WriteInto> UniformBuffer<T> {
 /// available to shaders runtime-sized arrays of parameters that are otherwise constant during shader execution, and are best
 /// suited to data that is relatively small in size as they are only guaranteed to support up to 16kB per binding.
 ///
-/// The contained data is stored in system RAM. [`write_buffer`](crate::render_resource::DynamicUniformBuffer::write_buffer) queues
+/// The contained data is stored in system RAM. [`write_buffer`](crate::gpu_resource::DynamicUniformBuffer::write_buffer) queues
 /// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
 /// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
 /// (vectors), or structures with fields that are vectors.
 ///
 /// Other options for storing GPU-accessible data are:
-/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
-/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
-/// * [`UniformBuffer`](crate::render_resource::UniformBuffer)
-/// * [`DynamicUniformBuffer`](crate::render_resource::DynamicUniformBuffer)
-/// * [`Texture`](crate::render_resource::Texture)
+/// * [`StorageBuffer`](crate::gpu_resource::StorageBuffer)
+/// * [`DynamicStorageBuffer`](crate::gpu_resource::DynamicStorageBuffer)
+/// * [`UniformBuffer`](crate::gpu_resource::UniformBuffer)
+/// * [`DynamicUniformBuffer`](crate::gpu_resource::DynamicUniformBuffer)
+/// * [`Texture`](crate::gpu_resource::Texture)
 ///
 /// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
 pub struct DynamicUniformBuffer<T: ShaderType> {
@@ -205,8 +205,8 @@ impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
         self.label.as_deref()
     }
 
-    /// Queues writing of data from system RAM to VRAM using the [`GPUDevice`](crate::renderer::GpuDevice)
-    /// and the provided [`GPUQueue`](crate::renderer::GpuQueue).
+    /// Queues writing of data from system RAM to VRAM using the [`GpuDevice`]
+    /// and the provided [`GpuQueue`].
     ///
     /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
     /// allocated does not have enough capacity, a new GPU-side buffer is created.

crates/bevy_gpu/src/lib.rs

@@ -81,7 +81,7 @@ const GPU_NOT_FOUND_ERROR_MESSAGE: &str = if cfg!(target_os = "linux") {
 };
 
 /// The GPU instance is used to initialize the [`GpuQueue`] and [`GpuDevice`],
-/// as well as to create [`WindowSurfaces`](crate::view::window::WindowSurfaces).
+/// as well as to create surfaces.
 #[derive(Resource, Clone, Debug, Deref, DerefMut)]
 pub struct GpuInstance(pub Arc<Instance>);
 

crates/bevy_gpu/src/settings.rs

@@ -13,8 +13,8 @@ pub enum WgpuSettingsPriority {
     WebGL2,
 }
 
-/// Provides configuration for renderer initialization. Use [`GPUDevice::features`](crate::renderer::GpuDevice::features),
-/// [`GPUDevice::limits`](crate::renderer::GpuDevice::limits), and the [`WgpuAdapterInfo`](crate::render_resource::WgpuAdapterInfo)
+/// Provides configuration for renderer initialization. Use [`GpuDevice::features`](crate::GpuDevice::features),
+/// [`GpuDevice::limits`](crate::GpuDevice::limits), and the [`WgpuAdapterInfo`](crate::gpu_resource::WgpuAdapterInfo)
 /// resource to get runtime information about the actual adapter, backend, features, and limits.
 /// NOTE: [`Backends::DX12`](Backends::DX12), [`Backends::METAL`](Backends::METAL), and
 /// [`Backends::VULKAN`](Backends::VULKAN) are enabled by default for non-web and the best choice

crates/bevy_internal/src/lib.rs

@@ -130,6 +130,10 @@ pub mod gltf {
 #[cfg(feature = "bevy_gpu")]
 pub mod gpu {
     //! The wgpu backend of Bevy.
+    //! Use [`GpuDevice::features`](crate::gpu::GpuDevice::features),
+    //! [`GpuDevice::limits`](crate::gpu::GpuDevice::limits), and the
+    //! [`WgpuAdapterInfo`](crate::gpu::gpu_resource::WgpuAdapterInfo) resource to
+    //! get runtime information about the actual adapter, backend, features, and limits.
     pub use bevy_gpu::*;
 }
 
@@ -141,11 +145,7 @@ pub mod pbr {
 
 #[cfg(feature = "bevy_render")]
 pub mod render {
-    //! Cameras, meshes, textures, shaders, and pipelines.
-    //! Use [`GPUDevice::features`](crate::render::renderer::GpuDevice::features),
-    //! [`GPUDevice::limits`](crate::render::renderer::GpuDevice::limits), and the
-    //! [`WgpuAdapterInfo`](crate::render::render_resource::WgpuAdapterInfo) resource to
-    //! get runtime information about the actual adapter, backend, features, and limits.
+    //! Cameras, meshes, textures.
     pub use bevy_render::*;
 }
 

crates/bevy_pbr/src/material.rs

@@ -57,7 +57,8 @@ use std::marker::PhantomData;
 /// # use bevy_pbr::{Material, MaterialMeshBundle};
 /// # use bevy_ecs::prelude::*;
 /// # use bevy_reflect::TypeUuid;
-/// # use bevy_render::{render_resource::{AsBindGroup, ShaderRef}, texture::Image, color::Color};
+/// # use bevy_render::{texture::Image, color::Color, as_bind_group::AsBindGroup};
+/// # use bevy_gpu::gpu_resource::*;
 /// # use bevy_asset::{Handle, AssetServer, Assets};
 ///
 /// #[derive(AsBindGroup, TypeUuid, Debug, Clone)]