forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make render and compute pipeline descriptors defaultable. (#19903)

Browse Source 
A few versions ago, wgpu made it possible to set shader entry point to
`None`, which will select the correct entry point in file where only a
single entrypoint is specified. This makes it possible to implement
`Default` for pipeline descriptors. This PR does so and attempts to
`..default()` everything possible.
This commit is contained in:
charlotte 🌸 2025-07-02 11:47:27 -07:00 committed by GitHub
parent 1b4cf02fc8
commit 18712f31f9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
52 changed files with 272 additions and 602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
crates/bevy_anti_aliasing/src/contrast_adaptive_sharpening/mod.rs
View File

@ -20,6 +20,7 @@ use bevy_render::{
view::{ExtractedView, ViewTarget},
Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
mod node;
@ -218,18 +219,14 @@ impl SpecializedRenderPipeline for CasPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: key.texture_format,
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

8
crates/bevy_anti_aliasing/src/fxaa/mod.rs
View File

@ -190,18 +190,14 @@ impl SpecializedRenderPipeline for FxaaPipeline {
format!("EDGE_THRESH_{}", key.edge_threshold.get_str()).into(),
format!("EDGE_THRESH_MIN_{}", key.edge_threshold_min.get_str()).into(),
],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: key.texture_format,
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

42
crates/bevy_anti_aliasing/src/smaa/mod.rs
View File

@ -64,13 +64,13 @@ use bevy_render::{
binding_types::{sampler, texture_2d, uniform_buffer},
AddressMode, BindGroup, BindGroupEntries, BindGroupLayout, BindGroupLayoutEntries,
CachedRenderPipelineId, ColorTargetState, ColorWrites, CompareFunction, DepthStencilState,
DynamicUniformBuffer, FilterMode, FragmentState, LoadOp, MultisampleState, Operations,
PipelineCache, PrimitiveState, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, SamplerBindingType,
SamplerDescriptor, Shader, ShaderDefVal, ShaderStages, ShaderType,
SpecializedRenderPipeline, SpecializedRenderPipelines, StencilFaceState, StencilOperation,
StencilState, StoreOp, TextureDescriptor, TextureDimension, TextureFormat,
TextureSampleType, TextureUsages, TextureView, VertexState,
DynamicUniformBuffer, FilterMode, FragmentState, LoadOp, Operations, PipelineCache,
RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor,
RenderPipeline, RenderPipelineDescriptor, SamplerBindingType, SamplerDescriptor, Shader,
ShaderDefVal, ShaderStages, ShaderType, SpecializedRenderPipeline,
SpecializedRenderPipelines, StencilFaceState, StencilOperation, StencilState, StoreOp,
TextureDescriptor, TextureDimension, TextureFormat, TextureSampleType, TextureUsages,
TextureView, VertexState,
},
renderer::{RenderContext, RenderDevice, RenderQueue},
texture::{CachedTexture, GpuImage, TextureCache},
@ -482,21 +482,19 @@ impl SpecializedRenderPipeline for SmaaEdgeDetectionPipeline {
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: shader_defs.clone(),
entry_point: "edge_detection_vertex_main".into(),
entry_point: Some("edge_detection_vertex_main".into()),
buffers: vec![],
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "luma_edge_detection_fragment_main".into(),
entry_point: Some("luma_edge_detection_fragment_main".into()),
targets: vec![Some(ColorTargetState {
format: TextureFormat::Rg8Unorm,
blend: None,
write_mask: ColorWrites::ALL,
})],
}),
push_constant_ranges: vec![],
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Stencil8,
depth_write_enabled: false,
@ -509,8 +507,7 @@ impl SpecializedRenderPipeline for SmaaEdgeDetectionPipeline {
},
bias: default(),
}),
multisample: MultisampleState::default(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -542,21 +539,19 @@ impl SpecializedRenderPipeline for SmaaBlendingWeightCalculationPipeline {
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: shader_defs.clone(),
entry_point: "blending_weight_calculation_vertex_main".into(),
entry_point: Some("blending_weight_calculation_vertex_main".into()),
buffers: vec![],
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "blending_weight_calculation_fragment_main".into(),
entry_point: Some("blending_weight_calculation_fragment_main".into()),
targets: vec![Some(ColorTargetState {
format: TextureFormat::Rgba8Unorm,
blend: None,
write_mask: ColorWrites::ALL,
})],
}),
push_constant_ranges: vec![],
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Stencil8,
depth_write_enabled: false,
@ -569,8 +564,7 @@ impl SpecializedRenderPipeline for SmaaBlendingWeightCalculationPipeline {
},
bias: default(),
}),
multisample: MultisampleState::default(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -590,24 +584,20 @@ impl SpecializedRenderPipeline for SmaaNeighborhoodBlendingPipeline {
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: shader_defs.clone(),
entry_point: "neighborhood_blending_vertex_main".into(),
entry_point: Some("neighborhood_blending_vertex_main".into()),
buffers: vec![],
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "neighborhood_blending_fragment_main".into(),
entry_point: Some("neighborhood_blending_fragment_main".into()),
targets: vec![Some(ColorTargetState {
format: key.texture_format,
blend: None,
write_mask: ColorWrites::ALL,
})],
}),
push_constant_ranges: vec![],
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

19
crates/bevy_anti_aliasing/src/taa/mod.rs
View File

@ -25,11 +25,11 @@ use bevy_render::{
render_resource::{
binding_types::{sampler, texture_2d, texture_depth_2d},
BindGroupEntries, BindGroupLayout, BindGroupLayoutEntries, CachedRenderPipelineId,
ColorTargetState, ColorWrites, FilterMode, FragmentState, MultisampleState, Operations,
PipelineCache, PrimitiveState, RenderPassColorAttachment, RenderPassDescriptor,
RenderPipelineDescriptor, Sampler, SamplerBindingType, SamplerDescriptor, Shader,
ShaderStages, SpecializedRenderPipeline, SpecializedRenderPipelines, TextureDescriptor,
TextureDimension, TextureFormat, TextureSampleType, TextureUsages,
ColorTargetState, ColorWrites, FilterMode, FragmentState, Operations, PipelineCache,
RenderPassColorAttachment, RenderPassDescriptor, RenderPipelineDescriptor, Sampler,
SamplerBindingType, SamplerDescriptor, Shader, ShaderStages, SpecializedRenderPipeline,
SpecializedRenderPipelines, TextureDescriptor, TextureDimension, TextureFormat,
TextureSampleType, TextureUsages,
},
renderer::{RenderContext, RenderDevice},
sync_component::SyncComponentPlugin,
@ -38,6 +38,7 @@ use bevy_render::{
view::{ExtractedView, Msaa, ViewTarget},
ExtractSchedule, MainWorld, Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
use tracing::warn;
/// Plugin for temporal anti-aliasing.
@ -320,7 +321,6 @@ impl SpecializedRenderPipeline for TaaPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "taa".into(),
targets: vec![
Some(ColorTargetState {
format,
@ -333,12 +333,9 @@ impl SpecializedRenderPipeline for TaaPipeline {
write_mask: ColorWrites::ALL,
}),
],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

8
crates/bevy_core_pipeline/src/auto_exposure/pipeline.rs
View File

@ -10,6 +10,7 @@ use bevy_render::{
renderer::RenderDevice,
view::ViewUniform,
};
use bevy_utils::default;
use core::num::NonZero;
#[derive(Resource)]
@ -82,12 +83,11 @@ impl SpecializedComputePipeline for AutoExposurePipeline {
layout: vec![self.histogram_layout.clone()],
shader: self.histogram_shader.clone(),
shader_defs: vec![],
entry_point: match pass {
entry_point: Some(match pass {
AutoExposurePass::Histogram => "compute_histogram".into(),
AutoExposurePass::Average => "compute_average".into(),
},
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
}),
..default()
}
}
}

14
crates/bevy_core_pipeline/src/blit/mod.rs
View File

@ -1,3 +1,4 @@
use crate::FullscreenShader;
use bevy_app::{App, Plugin};
use bevy_asset::{embedded_asset, load_embedded_asset, Handle};
use bevy_ecs::prelude::*;
@ -9,8 +10,7 @@ use bevy_render::{
renderer::RenderDevice,
RenderApp,
};
use crate::FullscreenShader;
use bevy_utils::default;
/// Adds support for specialized "blit pipelines", which can be used to write one texture to another.
pub struct BlitPlugin;
@ -85,22 +85,18 @@ impl SpecializedRenderPipeline for BlitPipeline {
vertex: self.fullscreen_shader.to_vertex_state(),
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs: vec![],
entry_point: "fs_main".into(),
targets: vec![Some(ColorTargetState {
format: key.texture_format,
blend: key.blend_state,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState {
count: key.samples,
..Default::default()
..default()
},
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

9
crates/bevy_core_pipeline/src/bloom/downsampling_pipeline.rs
View File

@ -16,6 +16,7 @@ use bevy_render::{
},
renderer::RenderDevice,
};
use bevy_utils::default;
#[derive(Component)]
pub struct BloomDownsamplingPipelineIds {
@ -130,18 +131,14 @@ impl SpecializedRenderPipeline for BloomDownsamplingPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point,
entry_point: Some(entry_point),
targets: vec![Some(ColorTargetState {
format: BLOOM_TEXTURE_FORMAT,
blend: None,
write_mask: ColorWrites::ALL,
})],
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

11
crates/bevy_core_pipeline/src/bloom/upsampling_pipeline.rs
View File

@ -18,6 +18,7 @@ use bevy_render::{
renderer::RenderDevice,
view::ViewTarget,
};
use bevy_utils::default;
#[derive(Component)]
pub struct UpsamplingPipelineIds {
@ -115,8 +116,7 @@ impl SpecializedRenderPipeline for BloomUpsamplingPipeline {
vertex: self.fullscreen_shader.to_vertex_state(),
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs: vec![],
entry_point: "upsample".into(),
entry_point: Some("upsample".into()),
targets: vec![Some(ColorTargetState {
format: texture_format,
blend: Some(BlendState {
@ -129,12 +129,9 @@ impl SpecializedRenderPipeline for BloomUpsamplingPipeline {
}),
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

13
crates/bevy_core_pipeline/src/deferred/copy_lighting_id.rs
View File

@ -15,13 +15,13 @@ use bevy_render::{
Render, RenderApp, RenderSystems,
};
use super::DEFERRED_LIGHTING_PASS_ID_DEPTH_FORMAT;
use bevy_ecs::query::QueryItem;
use bevy_render::{
render_graph::{NodeRunError, RenderGraphContext, ViewNode},
renderer::RenderContext,
};
use super::DEFERRED_LIGHTING_PASS_ID_DEPTH_FORMAT;
use bevy_utils::default;
pub struct CopyDeferredLightingIdPlugin;
@ -142,11 +142,8 @@ impl FromWorld for CopyDeferredLightingIdPipeline {
vertex: vertex_state,
fragment: Some(FragmentState {
shader,
shader_defs: vec![],
entry_point: "fragment".into(),
targets: vec![],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: DEFERRED_LIGHTING_PASS_ID_DEPTH_FORMAT,
depth_write_enabled: true,
@ -154,9 +151,7 @@ impl FromWorld for CopyDeferredLightingIdPipeline {
stencil: StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState::default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
});
Self {

10
crates/bevy_core_pipeline/src/dof/mod.rs
View File

@ -800,23 +800,19 @@ impl SpecializedRenderPipeline for DepthOfFieldPipeline {
RenderPipelineDescriptor {
label: Some("depth of field pipeline".into()),
layout,
push_constant_ranges: vec![],
vertex: self.fullscreen_shader.to_vertex_state(),
primitive: default(),
depth_stencil: None,
multisample: default(),
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: match key.pass {
entry_point: Some(match key.pass {
DofPass::GaussianHorizontal => "gaussian_horizontal".into(),
DofPass::GaussianVertical => "gaussian_vertical".into(),
DofPass::BokehPass0 => "bokeh_pass_0".into(),
DofPass::BokehPass1 => "bokeh_pass_1".into(),
},
}),
targets,
}),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

7
crates/bevy_core_pipeline/src/experimental/mip_generation/mod.rs
View File

@ -46,6 +46,7 @@ use bevy_render::{
view::{ExtractedView, NoIndirectDrawing, ViewDepthTexture},
Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
use bitflags::bitflags;
use tracing::debug;
@ -492,12 +493,12 @@ impl SpecializedComputePipeline for DownsampleDepthPipeline {
}],
shader: DOWNSAMPLE_DEPTH_SHADER_HANDLE,
shader_defs,
entry_point: if key.contains(DownsampleDepthPipelineKey::SECOND_PHASE) {
entry_point: Some(if key.contains(DownsampleDepthPipelineKey::SECOND_PHASE) {
"downsample_depth_second".into()
} else {
"downsample_depth_first".into()
},
zero_initialize_workgroup_memory: false,
}),
..default()
}
}
}

2
crates/bevy_core_pipeline/src/fullscreen_vertex_shader/mod.rs
View File

@ -33,7 +33,7 @@ impl FullscreenShader {
VertexState {
shader: self.0.clone(),
shader_defs: Vec::new(),
entry_point: "fullscreen_vertex_shader".into(),
entry_point: Some("fullscreen_vertex_shader".into()),
buffers: Vec::new(),
}
}

19
crates/bevy_core_pipeline/src/motion_blur/pipeline.rs
View File

@ -1,3 +1,4 @@
use crate::FullscreenShader;
use bevy_asset::{load_embedded_asset, Handle};
use bevy_ecs::{
component::Component,
@ -16,16 +17,14 @@ use bevy_render::{
texture_depth_2d_multisampled, uniform_buffer_sized,
},
BindGroupLayout, BindGroupLayoutEntries, CachedRenderPipelineId, ColorTargetState,
ColorWrites, FragmentState, MultisampleState, PipelineCache, PrimitiveState,
RenderPipelineDescriptor, Sampler, SamplerBindingType, SamplerDescriptor, Shader,
ShaderDefVal, ShaderStages, ShaderType, SpecializedRenderPipeline,
SpecializedRenderPipelines, TextureFormat, TextureSampleType,
ColorWrites, FragmentState, PipelineCache, RenderPipelineDescriptor, Sampler,
SamplerBindingType, SamplerDescriptor, Shader, ShaderDefVal, ShaderStages, ShaderType,
SpecializedRenderPipeline, SpecializedRenderPipelines, TextureFormat, TextureSampleType,
},
renderer::RenderDevice,
view::{ExtractedView, Msaa, ViewTarget},
};
use crate::FullscreenShader;
use bevy_utils::default;
use super::MotionBlurUniform;
@ -139,7 +138,6 @@ impl SpecializedRenderPipeline for MotionBlurPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -149,12 +147,9 @@ impl SpecializedRenderPipeline for MotionBlurPipeline {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}

16
crates/bevy_core_pipeline/src/oit/resolve/mod.rs
View File

@ -1,3 +1,4 @@
use super::OitBuffers;
use crate::{oit::OrderIndependentTransparencySettings, FullscreenShader};
use bevy_app::Plugin;
use bevy_asset::{embedded_asset, load_embedded_asset, AssetServer};
@ -12,17 +13,16 @@ use bevy_render::{
binding_types::{storage_buffer_sized, texture_depth_2d, uniform_buffer},
BindGroup, BindGroupEntries, BindGroupLayout, BindGroupLayoutEntries, BlendComponent,
BlendState, CachedRenderPipelineId, ColorTargetState, ColorWrites, DownlevelFlags,
FragmentState, MultisampleState, PipelineCache, PrimitiveState, RenderPipelineDescriptor,
ShaderDefVal, ShaderStages, TextureFormat,
FragmentState, PipelineCache, RenderPipelineDescriptor, ShaderDefVal, ShaderStages,
TextureFormat,
},
renderer::{RenderAdapter, RenderDevice},
view::{ExtractedView, ViewTarget, ViewUniform, ViewUniforms},
Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
use tracing::warn;
use super::OitBuffers;
/// Contains the render node used to run the resolve pass.
pub mod node;
@ -213,7 +213,6 @@ fn specialize_oit_resolve_pipeline(
resolve_pipeline.oit_depth_bind_group_layout.clone(),
],
fragment: Some(FragmentState {
entry_point: "fragment".into(),
shader: load_embedded_asset!(asset_server, "oit_resolve.wgsl"),
shader_defs: vec![ShaderDefVal::UInt(
"LAYER_COUNT".into(),
@ -227,13 +226,10 @@ fn specialize_oit_resolve_pipeline(
}),
write_mask: ColorWrites::ALL,
})],
..default()
}),
vertex: fullscreen_shader.to_vertex_state(),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}

9
crates/bevy_core_pipeline/src/post_process/mod.rs
View File

@ -326,19 +326,14 @@ impl SpecializedRenderPipeline for PostProcessingPipeline {
vertex: self.fullscreen_shader.to_vertex_state(),
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs: vec![],
entry_point: "fragment_main".into(),
targets: vec![Some(ColorTargetState {
format: key.texture_format,
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: default(),
depth_stencil: None,
multisample: default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}

12
crates/bevy_core_pipeline/src/skybox/mod.rs
View File

@ -28,6 +28,7 @@ use bevy_render::{
Render, RenderApp, RenderSystems,
};
use bevy_transform::components::Transform;
use bevy_utils::default;
use prepass::SkyboxPrepassPipeline;
use crate::{core_3d::CORE_3D_DEPTH_FORMAT, prepass::PreviousViewUniforms};
@ -192,14 +193,10 @@ impl SpecializedRenderPipeline for SkyboxPipeline {
RenderPipelineDescriptor {
label: Some("skybox_pipeline".into()),
layout: vec![self.bind_group_layout.clone()],
push_constant_ranges: Vec::new(),
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: Vec::new(),
entry_point: "skybox_vertex".into(),
buffers: Vec::new(),
..default()
},
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: key.depth_format,
depth_write_enabled: false,
@ -223,8 +220,6 @@ impl SpecializedRenderPipeline for SkyboxPipeline {
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs: Vec::new(),
entry_point: "skybox_fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -235,8 +230,9 @@ impl SpecializedRenderPipeline for SkyboxPipeline {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

7
crates/bevy_core_pipeline/src/skybox/prepass.rs
View File

@ -87,9 +87,7 @@ impl SpecializedRenderPipeline for SkyboxPrepassPipeline {
RenderPipelineDescriptor {
label: Some("skybox_prepass_pipeline".into()),
layout: vec![self.bind_group_layout.clone()],
push_constant_ranges: vec![],
vertex: self.fullscreen_shader.to_vertex_state(),
primitive: default(),
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
depth_write_enabled: false,
@ -104,11 +102,10 @@ impl SpecializedRenderPipeline for SkyboxPrepassPipeline {
},
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs: vec![],
entry_point: "fragment".into(),
targets: prepass_target_descriptors(key.normal_prepass, true, false),
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

8
crates/bevy_core_pipeline/src/tonemapping/mod.rs
View File

@ -279,18 +279,14 @@ impl SpecializedRenderPipeline for TonemappingPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: ViewTarget::TEXTURE_FORMAT_HDR,
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

16
crates/bevy_gizmos/src/pipeline_2d.rs
View File

@ -29,6 +29,7 @@ use bevy_render::{
Render, RenderApp, RenderSystems,
};
use bevy_sprite::{Mesh2dPipeline, Mesh2dPipelineKey, SetMesh2dViewBindGroup};
use bevy_utils::default;
use tracing::error;
pub struct LineGizmo2dPlugin;
@ -128,14 +129,14 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: line_gizmo_vertex_buffer_layouts(key.strip),
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: fragment_entry_point.into(),
entry_point: Some(fragment_entry_point.into()),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
@ -143,7 +144,6 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
})],
}),
layout,
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: CORE_2D_DEPTH_FORMAT,
depth_write_enabled: false,
@ -166,8 +166,7 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
alpha_to_coverage_enabled: false,
},
label: Some("LineGizmo Pipeline 2D".into()),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -231,19 +230,19 @@ impl SpecializedRenderPipeline for LineJointGizmoPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: entry_point.into(),
entry_point: Some(entry_point.into()),
shader_defs: shader_defs.clone(),
buffers: line_joint_gizmo_vertex_buffer_layouts(),
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout,
primitive: PrimitiveState::default(),
@ -269,8 +268,7 @@ impl SpecializedRenderPipeline for LineJointGizmoPipeline {
alpha_to_coverage_enabled: false,
},
label: Some("LineJointGizmo Pipeline 2D".into()),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}

17
crates/bevy_gizmos/src/pipeline_3d.rs
View File

@ -33,6 +33,7 @@ use bevy_render::{
view::{ExtractedView, Msaa, RenderLayers, ViewTarget},
Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
use tracing::error;
pub struct LineGizmo3dPlugin;
@ -132,14 +133,14 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: line_gizmo_vertex_buffer_layouts(key.strip),
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: fragment_entry_point.into(),
entry_point: Some(fragment_entry_point.into()),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
@ -147,7 +148,6 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
})],
}),
layout,
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
depth_write_enabled: true,
@ -161,8 +161,7 @@ impl SpecializedRenderPipeline for LineGizmoPipeline {
alpha_to_coverage_enabled: false,
},
label: Some("LineGizmo 3d Pipeline".into()),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -232,22 +231,21 @@ impl SpecializedRenderPipeline for LineJointGizmoPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: entry_point.into(),
entry_point: Some(entry_point.into()),
shader_defs: shader_defs.clone(),
buffers: line_joint_gizmo_vertex_buffer_layouts(),
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout,
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
depth_write_enabled: true,
@ -261,8 +259,7 @@ impl SpecializedRenderPipeline for LineJointGizmoPipeline {
alpha_to_coverage_enabled: false,
},
label: Some("LineJointGizmo 3d Pipeline".into()),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}

40
crates/bevy_pbr/src/atmosphere/resources.rs
View File

@ -1,3 +1,4 @@
use crate::{GpuLights, LightMeta};
use bevy_asset::{load_embedded_asset, Handle};
use bevy_core_pipeline::{core_3d::Camera3d, FullscreenShader};
use bevy_ecs::{
@ -18,8 +19,7 @@ use bevy_render::{
texture::{CachedTexture, TextureCache},
view::{ExtractedView, Msaa, ViewDepthTexture, ViewUniform, ViewUniforms},
};
use crate::{GpuLights, LightMeta};
use bevy_utils::default;
use super::{Atmosphere, AtmosphereSettings};
@ -276,42 +276,30 @@ impl FromWorld for AtmosphereLutPipelines {
let transmittance_lut = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("transmittance_lut_pipeline".into()),
layout: vec![layouts.transmittance_lut.clone()],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "transmittance_lut.wgsl"),
shader_defs: vec![],
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
});
let multiscattering_lut =
pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("multi_scattering_lut_pipeline".into()),
layout: vec![layouts.multiscattering_lut.clone()],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "multiscattering_lut.wgsl"),
shader_defs: vec![],
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
});
let sky_view_lut = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("sky_view_lut_pipeline".into()),
layout: vec![layouts.sky_view_lut.clone()],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "sky_view_lut.wgsl"),
shader_defs: vec![],
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
});
let aerial_view_lut = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("aerial_view_lut_pipeline".into()),
layout: vec![layouts.aerial_view_lut.clone()],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "aerial_view_lut.wgsl"),
shader_defs: vec![],
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
});
Self {
@ -358,20 +346,10 @@ impl SpecializedRenderPipeline for RenderSkyBindGroupLayouts {
} else {
self.render_sky_msaa.clone()
}],
push_constant_ranges: vec![],
vertex: self.fullscreen_shader.to_vertex_state(),
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState {
count: key.msaa_samples,
mask: !0,
alpha_to_coverage_enabled: false,
},
zero_initialize_workgroup_memory: false,
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "main".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::Rgba16Float,
blend: Some(BlendState {
@ -388,7 +366,13 @@ impl SpecializedRenderPipeline for RenderSkyBindGroupLayouts {
}),
write_mask: ColorWrites::ALL,
})],
..default()
}),
multisample: MultisampleState {
count: key.msaa_samples,
..default()
},
..default()
}
}
}

11
crates/bevy_pbr/src/deferred/mod.rs
View File

@ -31,6 +31,7 @@ use bevy_render::{
view::{ExtractedView, ViewTarget, ViewUniformOffset},
Render, RenderApp, RenderSystems,
};
use bevy_utils::default;
pub struct DeferredPbrLightingPlugin;
@ -358,13 +359,11 @@ impl SpecializedRenderPipeline for DeferredLightingLayout {
vertex: VertexState {
shader: self.deferred_lighting_shader.clone(),
shader_defs: shader_defs.clone(),
entry_point: "vertex".into(),
buffers: Vec::new(),
..default()
},
fragment: Some(FragmentState {
shader: self.deferred_lighting_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.contains(MeshPipelineKey::HDR) {
ViewTarget::TEXTURE_FORMAT_HDR
@ -374,8 +373,8 @@ impl SpecializedRenderPipeline for DeferredLightingLayout {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: DEFERRED_LIGHTING_PASS_ID_DEPTH_FORMAT,
depth_write_enabled: false,
@ -392,9 +391,7 @@ impl SpecializedRenderPipeline for DeferredLightingLayout {
clamp: 0.0,
},
}),
multisample: MultisampleState::default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
}
}
}

9
crates/bevy_pbr/src/meshlet/material_pipeline_prepare.rs
View File

@ -17,6 +17,7 @@ use bevy_render::{
render_resource::*,
view::ExtractedView,
};
use bevy_utils::default;
use core::any::{Any, TypeId};
/// A list of `(Material ID, Pipeline, BindGroup)` for a view for use in [`super::MeshletMainOpaquePass3dNode`].
@ -371,7 +372,7 @@ pub fn prepare_material_meshlet_meshes_prepass(
let entry_point = if fragment_shader == meshlet_pipelines.meshlet_mesh_material {
material_fragment.entry_point.clone()
} else {
"prepass_fragment".into()
None
};
let pipeline_descriptor = RenderPipelineDescriptor {
@ -387,12 +388,11 @@ pub fn prepare_material_meshlet_meshes_prepass(
.unwrap()
.clone(),
],
push_constant_ranges: vec![],
vertex: VertexState {
shader: meshlet_pipelines.meshlet_mesh_material.clone(),
shader_defs: shader_defs.clone(),
entry_point: material_pipeline_descriptor.vertex.entry_point,
buffers: Vec::new(),
..default()
},
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
@ -402,14 +402,13 @@ pub fn prepare_material_meshlet_meshes_prepass(
stencil: StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: fragment_shader,
shader_defs,
entry_point,
targets: material_fragment.targets,
}),
zero_initialize_workgroup_memory: false,
..default()
};
let material_id = instance_manager.get_material_id(material_id);

2
crates/bevy_pbr/src/meshlet/meshlet_mesh_material.wgsl
View File

@ -15,6 +15,7 @@ fn vertex(@builtin(vertex_index) vertex_input: u32) -> @builtin(position) vec4<f
return vec4(uv_to_ndc(uv), material_depth, 1.0);
}
#ifdef PREPASS_FRAGMENT
@fragment
fn fragment(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32> {
let vertex_output = resolve_vertex_output(frag_coord);
@ -22,6 +23,7 @@ fn fragment(@builtin(position) frag_coord: vec4<f32>) -> @location(0) vec4<f32>
let color = vec3(rand_f(&rng), rand_f(&rng), rand_f(&rng));
return vec4(color, 1.0);
}
#endif
#ifdef PREPASS_FRAGMENT
@fragment

133
crates/bevy_pbr/src/meshlet/pipelines.rs
View File

@ -9,6 +9,7 @@ use bevy_ecs::{
world::{FromWorld, World},
};
use bevy_render::render_resource::*;
use bevy_utils::default;
#[derive(Resource)]
pub struct MeshletPipelines {
@ -112,8 +113,7 @@ impl FromWorld for MeshletPipelines {
}],
shader: clear_visibility_buffer.clone(),
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
entry_point: "clear_visibility_buffer".into(),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -126,9 +126,7 @@ impl FromWorld for MeshletPipelines {
range: 0..8,
}],
shader: clear_visibility_buffer,
shader_defs: vec![],
entry_point: "clear_visibility_buffer".into(),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -144,8 +142,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_INSTANCE_CULLING_PASS".into(),
"MESHLET_FIRST_CULLING_PASS".into(),
],
entry_point: "cull_instances".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
second_instance_cull: pipeline_cache.queue_compute_pipeline(
@ -161,8 +158,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_INSTANCE_CULLING_PASS".into(),
"MESHLET_SECOND_CULLING_PASS".into(),
],
entry_point: "cull_instances".into(),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -178,8 +174,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_BVH_CULLING_PASS".into(),
"MESHLET_FIRST_CULLING_PASS".into(),
],
entry_point: "cull_bvh".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
second_bvh_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
@ -194,8 +189,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_BVH_CULLING_PASS".into(),
"MESHLET_SECOND_CULLING_PASS".into(),
],
entry_point: "cull_bvh".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
first_meshlet_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
@ -210,8 +204,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_CLUSTER_CULLING_PASS".into(),
"MESHLET_FIRST_CULLING_PASS".into(),
],
entry_point: "cull_clusters".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
second_meshlet_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
@ -226,8 +219,7 @@ impl FromWorld for MeshletPipelines {
"MESHLET_CLUSTER_CULLING_PASS".into(),
"MESHLET_SECOND_CULLING_PASS".into(),
],
entry_point: "cull_clusters".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
downsample_depth_first: pipeline_cache.queue_compute_pipeline(
@ -243,8 +235,8 @@ impl FromWorld for MeshletPipelines {
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
"MESHLET".into(),
],
entry_point: "downsample_depth_first".into(),
zero_initialize_workgroup_memory: false,
entry_point: Some("downsample_depth_first".into()),
..default()
},
),
@ -261,8 +253,8 @@ impl FromWorld for MeshletPipelines {
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
"MESHLET".into(),
],
entry_point: "downsample_depth_second".into(),
zero_initialize_workgroup_memory: false,
entry_point: Some("downsample_depth_second".into()),
..default()
},
),
@ -276,8 +268,8 @@ impl FromWorld for MeshletPipelines {
}],
shader: DOWNSAMPLE_DEPTH_SHADER_HANDLE,
shader_defs: vec!["MESHLET".into()],
entry_point: "downsample_depth_first".into(),
zero_initialize_workgroup_memory: false,
entry_point: Some("downsample_depth_first".into()),
..default()
},
),
@ -291,7 +283,7 @@ impl FromWorld for MeshletPipelines {
}],
shader: DOWNSAMPLE_DEPTH_SHADER_HANDLE,
shader_defs: vec!["MESHLET".into()],
entry_point: "downsample_depth_second".into(),
entry_point: Some("downsample_depth_second".into()),
zero_initialize_workgroup_memory: false,
},
),
@ -312,8 +304,7 @@ impl FromWorld for MeshletPipelines {
}
.into(),
],
entry_point: "rasterize_cluster".into(),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -334,8 +325,7 @@ impl FromWorld for MeshletPipelines {
}
.into(),
],
entry_point: "rasterize_cluster".into(),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -353,34 +343,22 @@ impl FromWorld for MeshletPipelines {
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
],
entry_point: "vertex".into(),
buffers: vec![],
..default()
},
primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
},
depth_stencil: None,
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: visibility_buffer_hardware_raster.clone(),
shader_defs: vec![
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
"MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::R8Uint,
blend: None,
write_mask: ColorWrites::empty(),
})],
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -397,31 +375,19 @@ impl FromWorld for MeshletPipelines {
vertex: VertexState {
shader: visibility_buffer_hardware_raster.clone(),
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
entry_point: "vertex".into(),
buffers: vec![],
..default()
},
primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
},
depth_stencil: None,
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: visibility_buffer_hardware_raster.clone(),
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::R8Uint,
blend: None,
write_mask: ColorWrites::empty(),
})],
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -439,39 +405,25 @@ impl FromWorld for MeshletPipelines {
vertex: VertexState {
shader: visibility_buffer_hardware_raster.clone(),
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
entry_point: "vertex".into(),
buffers: vec![],
..default()
},
primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
unclipped_depth: true,
polygon_mode: PolygonMode::Fill,
conservative: false,
},
depth_stencil: None,
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: visibility_buffer_hardware_raster,
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::R8Uint,
blend: None,
write_mask: ColorWrites::empty(),
})],
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
}),
resolve_depth: pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
label: Some("meshlet_resolve_depth_pipeline".into()),
layout: vec![resolve_depth_layout],
push_constant_ranges: vec![],
vertex: vertex_state.clone(),
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
depth_write_enabled: true,
@ -479,23 +431,20 @@ impl FromWorld for MeshletPipelines {
stencil: StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: resolve_render_targets.clone(),
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
entry_point: "resolve_depth".into(),
targets: vec![],
entry_point: Some("resolve_depth".into()),
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
}),
resolve_depth_shadow_view: pipeline_cache.queue_render_pipeline(
RenderPipelineDescriptor {
label: Some("meshlet_resolve_depth_pipeline".into()),
layout: vec![resolve_depth_shadow_view_layout],
push_constant_ranges: vec![],
vertex: vertex_state.clone(),
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
depth_write_enabled: true,
@ -503,14 +452,12 @@ impl FromWorld for MeshletPipelines {
stencil: StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: resolve_render_targets.clone(),
shader_defs: vec![],
entry_point: "resolve_depth".into(),
targets: vec![],
entry_point: Some("resolve_depth".into()),
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
},
),
@ -518,7 +465,6 @@ impl FromWorld for MeshletPipelines {
RenderPipelineDescriptor {
label: Some("meshlet_resolve_material_depth_pipeline".into()),
layout: vec![resolve_material_depth_layout],
push_constant_ranges: vec![],
vertex: vertex_state,
primitive: PrimitiveState::default(),
depth_stencil: Some(DepthStencilState {
@ -528,21 +474,19 @@ impl FromWorld for MeshletPipelines {
stencil: StencilState::default(),
bias: DepthBiasState::default(),
}),
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: resolve_render_targets,
shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
entry_point: "resolve_material_depth".into(),
entry_point: Some("resolve_material_depth".into()),
targets: vec![],
}),
zero_initialize_workgroup_memory: false,
..default()
},
),
fill_counts: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("meshlet_fill_counts_pipeline".into()),
layout: vec![fill_counts_layout],
push_constant_ranges: vec![],
shader: fill_counts,
shader_defs: vec![if remap_1d_to_2d_dispatch_layout.is_some() {
"MESHLET_2D_DISPATCH"
@ -550,8 +494,7 @@ impl FromWorld for MeshletPipelines {
""
}
.into()],
entry_point: "fill_counts".into(),
zero_initialize_workgroup_memory: false,
..default()
}),
remap_1d_to_2d_dispatch: remap_1d_to_2d_dispatch_layout.map(|layout| {
@ -563,9 +506,7 @@ impl FromWorld for MeshletPipelines {
range: 0..4,
}],
shader: remap_1d_to_2d_dispatch,
shader_defs: vec![],
entry_point: "remap_dispatch".into(),
zero_initialize_workgroup_memory: false,
..default()
})
}),

14
crates/bevy_pbr/src/prepass/mod.rs
View File

@ -66,6 +66,7 @@ use bevy_render::{
view::RenderVisibleEntities,
RenderSystems::{PrepareAssets, PrepareResources},
};
use bevy_utils::default;
use core::marker::PhantomData;
/// Sets up everything required to use the prepass pipeline.
@ -571,9 +572,9 @@ impl PrepassPipeline {
FragmentState {
shader: frag_shader_handle,
entry_point: "fragment".into(),
shader_defs: shader_defs.clone(),
targets,
..default()
}
});
@ -592,20 +593,16 @@ impl PrepassPipeline {
let descriptor = RenderPipelineDescriptor {
vertex: VertexState {
shader: vert_shader_handle,
entry_point: "vertex".into(),
shader_defs,
buffers: vec![vertex_buffer_layout],
..default()
},
fragment,
layout: bind_group_layouts,
primitive: PrimitiveState {
topology: mesh_key.primitive_topology(),
strip_index_format: None,
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth,
polygon_mode: PolygonMode::Fill,
conservative: false,
..default()
},
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
@ -628,9 +625,8 @@ impl PrepassPipeline {
mask: !0,
alpha_to_coverage_enabled: false,
},
push_constant_ranges: vec![],
label: Some("prepass_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
};
Ok(descriptor)
}

14
crates/bevy_pbr/src/render/gpu_preprocess.rs
View File

@ -52,7 +52,7 @@ use bevy_render::{
view::{ExtractedView, NoIndirectDrawing, ViewUniform, ViewUniformOffset, ViewUniforms},
Render, RenderApp, RenderSystems,
};
use bevy_utils::TypeIdMap;
use bevy_utils::{default, TypeIdMap};
use bitflags::bitflags;
use smallvec::{smallvec, SmallVec};
use tracing::warn;
@ -1275,8 +1275,7 @@ impl SpecializedComputePipeline for PreprocessPipeline {
},
shader: self.shader.clone(),
shader_defs,
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -1637,11 +1636,8 @@ impl SpecializedComputePipeline for ResetIndirectBatchSetsPipeline {
ComputePipelineDescriptor {
label: Some("reset indirect batch sets".into()),
layout: vec![self.bind_group_layout.clone()],
push_constant_ranges: vec![],
shader: self.shader.clone(),
shader_defs: vec![],
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}
@ -1691,11 +1687,9 @@ impl SpecializedComputePipeline for BuildIndirectParametersPipeline {
ComputePipelineDescriptor {
label: Some(label.into()),
layout: vec![self.bind_group_layout.clone()],
push_constant_ranges: vec![],
shader: self.shader.clone(),
shader_defs,
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

12
crates/bevy_pbr/src/render/mesh.rs
View File

@ -2581,30 +2581,26 @@ impl SpecializedMeshPipeline for MeshPipeline {
Ok(RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_buffer_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend,
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: bind_group_layout,
push_constant_ranges: vec![],
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: key.primitive_topology(),
strip_index_format: None,
..default()
},
depth_stencil: Some(DepthStencilState {
format: CORE_3D_DEPTH_FORMAT,
@ -2628,7 +2624,7 @@ impl SpecializedMeshPipeline for MeshPipeline {
alpha_to_coverage_enabled,
},
label: Some(label),
zero_initialize_workgroup_memory: false,
..default()
})
}
}

14
crates/bevy_pbr/src/ssao/mod.rs
View File

@ -412,11 +412,8 @@ impl FromWorld for SsaoPipelines {
preprocess_depth_bind_group_layout.clone(),
common_bind_group_layout.clone(),
],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "preprocess_depth.wgsl"),
shader_defs: Vec::new(),
entry_point: "preprocess_depth".into(),
zero_initialize_workgroup_memory: false,
..default()
});
let spatial_denoise_pipeline =
@ -426,11 +423,8 @@ impl FromWorld for SsaoPipelines {
spatial_denoise_bind_group_layout.clone(),
common_bind_group_layout.clone(),
],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "spatial_denoise.wgsl"),
shader_defs: Vec::new(),
entry_point: "spatial_denoise".into(),
zero_initialize_workgroup_memory: false,
..default()
});
Self {
@ -481,11 +475,9 @@ impl SpecializedComputePipeline for SsaoPipelines {
self.ssao_bind_group_layout.clone(),
self.common_bind_group_layout.clone(),
],
push_constant_ranges: vec![],
shader: self.shader.clone(),
shader_defs,
entry_point: "ssao".into(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

8
crates/bevy_pbr/src/ssr/mod.rs
View File

@ -548,7 +548,6 @@ impl SpecializedRenderPipeline for ScreenSpaceReflectionsPipeline {
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.is_hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -558,12 +557,9 @@ impl SpecializedRenderPipeline for ScreenSpaceReflectionsPipeline {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
push_constant_ranges: vec![],
primitive: default(),
depth_stencil: None,
multisample: default(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

17
crates/bevy_pbr/src/volumetric_fog/render.rs
View File

@ -31,10 +31,10 @@ use bevy_render::{
},
BindGroupLayout, BindGroupLayoutEntries, BindingResource, BlendComponent, BlendFactor,
BlendOperation, BlendState, CachedRenderPipelineId, ColorTargetState, ColorWrites,
DynamicBindGroupEntries, DynamicUniformBuffer, Face, FragmentState, LoadOp,
MultisampleState, Operations, PipelineCache, PrimitiveState, RenderPassColorAttachment,
RenderPassDescriptor, RenderPipelineDescriptor, SamplerBindingType, Shader, ShaderStages,
ShaderType, SpecializedRenderPipeline, SpecializedRenderPipelines, StoreOp, TextureFormat,
DynamicBindGroupEntries, DynamicUniformBuffer, Face, FragmentState, LoadOp, Operations,
PipelineCache, PrimitiveState, RenderPassColorAttachment, RenderPassDescriptor,
RenderPipelineDescriptor, SamplerBindingType, Shader, ShaderStages, ShaderType,
SpecializedRenderPipeline, SpecializedRenderPipelines, StoreOp, TextureFormat,
TextureSampleType, TextureUsages, VertexState,
},
renderer::{RenderContext, RenderDevice, RenderQueue},
@ -566,23 +566,19 @@ impl SpecializedRenderPipeline for VolumetricFogPipeline {
RenderPipelineDescriptor {
label: Some("volumetric lighting pipeline".into()),
layout,
push_constant_ranges: vec![],
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: shader_defs.clone(),
entry_point: "vertex".into(),
buffers: vec![vertex_format],
..default()
},
primitive: PrimitiveState {
cull_mode: Some(Face::Back),
..default()
},
depth_stencil: None,
multisample: MultisampleState::default(),
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.flags.contains(VolumetricFogPipelineKeyFlags::HDR) {
ViewTarget::TEXTURE_FORMAT_HDR
@ -606,8 +602,9 @@ impl SpecializedRenderPipeline for VolumetricFogPipeline {
}),
write_mask: ColorWrites::ALL,
})],
..default()
}),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

26
crates/bevy_render/src/render_resource/pipeline.rs
View File

@ -88,7 +88,7 @@ impl Deref for ComputePipeline {
}
/// Describes a render (graphics) pipeline.
#[derive(Clone, Debug, PartialEq)]
#[derive(Clone, Debug, PartialEq, Default)]
pub struct RenderPipelineDescriptor {
/// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
pub label: Option<Cow<'static, str>>,
@ -112,33 +112,33 @@ pub struct RenderPipelineDescriptor {
pub zero_initialize_workgroup_memory: bool,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[derive(Clone, Debug, Eq, PartialEq, Default)]
pub struct VertexState {
/// The compiled shader module for this stage.
pub shader: Handle<Shader>,
pub shader_defs: Vec<ShaderDefVal>,
/// The name of the entry point in the compiled shader. There must be a
/// function with this name in the shader.
pub entry_point: Cow<'static, str>,
/// The name of the entry point in the compiled shader, or `None` if the default entry point
/// is used.
pub entry_point: Option<Cow<'static, str>>,
/// The format of any vertex buffers used with this pipeline.
pub buffers: Vec<VertexBufferLayout>,
}
/// Describes the fragment process in a render pipeline.
#[derive(Clone, Debug, PartialEq, Eq)]
#[derive(Clone, Debug, PartialEq, Eq, Default)]
pub struct FragmentState {
/// The compiled shader module for this stage.
pub shader: Handle<Shader>,
pub shader_defs: Vec<ShaderDefVal>,
/// The name of the entry point in the compiled shader. There must be a
/// function with this name in the shader.
pub entry_point: Cow<'static, str>,
/// The name of the entry point in the compiled shader, or `None` if the default entry point
/// is used.
pub entry_point: Option<Cow<'static, str>>,
/// The color state of the render targets.
pub targets: Vec<Option<ColorTargetState>>,
}
/// Describes a compute pipeline.
#[derive(Clone, Debug, PartialEq, Eq)]
#[derive(Clone, Debug, PartialEq, Eq, Default)]
pub struct ComputePipelineDescriptor {
pub label: Option<Cow<'static, str>>,
pub layout: Vec<BindGroupLayout>,
@ -146,9 +146,9 @@ pub struct ComputePipelineDescriptor {
/// The compiled shader module for this stage.
pub shader: Handle<Shader>,
pub shader_defs: Vec<ShaderDefVal>,
/// The name of the entry point in the compiled shader. There must be a
/// function with this name in the shader.
pub entry_point: Cow<'static, str>,
/// The name of the entry point in the compiled shader, or `None` if the default entry point
/// is used.
pub entry_point: Option<Cow<'static, str>>,
/// Whether to zero-initialize workgroup memory by default. If you're not sure, set this to true.
/// If this is false, reading from workgroup variables before writing to them will result in garbage values.
pub zero_initialize_workgroup_memory: bool,

10
crates/bevy_render/src/render_resource/pipeline_cache.rs
View File

@ -14,7 +14,7 @@ use bevy_platform::collections::{hash_map::EntryRef, HashMap, HashSet};
use bevy_tasks::Task;
use bevy_utils::default;
use bevy_utils::WgpuWrapper;
use core::{future::Future, hash::Hash, mem, ops::Deref};
use core::{future::Future, hash::Hash, mem};
use naga::valid::Capabilities;
use std::sync::{Mutex, PoisonError};
use thiserror::Error;
@ -869,7 +869,7 @@ impl PipelineCache {
let fragment_data = descriptor.fragment.as_ref().map(|fragment| {
(
fragment_module.unwrap(),
fragment.entry_point.deref(),
fragment.entry_point.as_deref(),
fragment.targets.as_slice(),
)
});
@ -889,7 +889,7 @@ impl PipelineCache {
primitive: descriptor.primitive,
vertex: RawVertexState {
buffers: &vertex_buffer_layouts,
entry_point: Some(descriptor.vertex.entry_point.deref()),
entry_point: descriptor.vertex.entry_point.as_deref(),
module: &vertex_module,
// TODO: Should this be the same as the fragment compilation options?
compilation_options: compilation_options.clone(),
@ -897,7 +897,7 @@ impl PipelineCache {
fragment: fragment_data
.as_ref()
.map(|(module, entry_point, targets)| RawFragmentState {
entry_point: Some(entry_point),
entry_point: entry_point.as_deref(),
module,
targets,
// TODO: Should this be the same as the vertex compilation options?
@ -955,7 +955,7 @@ impl PipelineCache {
label: descriptor.label.as_deref(),
layout: layout.as_ref().map(|layout| -> &PipelineLayout { layout }),
module: &compute_module,
entry_point: Some(&descriptor.entry_point),
entry_point: descriptor.entry_point.as_deref(),
// TODO: Expose the rest of this somehow
compilation_options: PipelineCompilationOptions {
constants: &[],

11
crates/bevy_render/src/view/window/screenshot.rs
View File

@ -461,29 +461,24 @@ impl SpecializedRenderPipeline for ScreenshotToScreenPipeline {
label: Some(Cow::Borrowed("screenshot-to-screen")),
layout: vec![self.bind_group_layout.clone()],
vertex: VertexState {
buffers: vec![],
shader_defs: vec![],
entry_point: Cow::Borrowed("vs_main"),
shader: self.shader.clone(),
..default()
},
primitive: wgpu::PrimitiveState {
cull_mode: Some(wgpu::Face::Back),
..Default::default()
},
depth_stencil: None,
multisample: Default::default(),
fragment: Some(FragmentState {
shader: self.shader.clone(),
entry_point: Cow::Borrowed("fs_main"),
shader_defs: vec![],
targets: vec![Some(wgpu::ColorTargetState {
format: key,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
..default()
}),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

1
crates/bevy_solari/Cargo.toml
View File

@ -26,6 +26,7 @@ bevy_platform = { path = "../bevy_platform", version = "0.17.0-dev", default-fea
bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev" }
bevy_render = { path = "../bevy_render", version = "0.17.0-dev" }
bevy_image = { path = "../bevy_image", version = "0.17.0-dev" }
bevy_utils = { path = "../bevy_utils", version = "0.17.0-dev" }
bevy_transform = { path = "../bevy_transform", version = "0.17.0-dev" }
# other

6
crates/bevy_solari/src/pathtracer/node.rs
View File

@ -17,6 +17,7 @@ use bevy_render::{
renderer::{RenderContext, RenderDevice},
view::{ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms},
};
use bevy_utils::default;
pub mod graph {
use bevy_render::render_graph::RenderLabel;
@ -119,11 +120,8 @@ impl FromWorld for PathtracerNode {
scene_bindings.bind_group_layout.clone(),
bind_group_layout.clone(),
],
push_constant_ranges: vec![],
shader: load_embedded_asset!(world, "pathtracer.wgsl"),
shader_defs: vec![],
entry_point: "pathtrace".into(),
zero_initialize_workgroup_memory: false,
..default()
});
Self {

11
crates/bevy_solari/src/realtime/node.rs
View File

@ -25,6 +25,7 @@ use bevy_render::{
renderer::{RenderContext, RenderDevice},
view::{ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms},
};
use bevy_utils::default;
pub mod graph {
use bevy_render::render_graph::RenderLabel;
@ -215,9 +216,8 @@ impl FromWorld for SolariLightingNode {
range: 0..8,
}],
shader: load_embedded_asset!(world, "restir_di.wgsl"),
shader_defs: vec![],
entry_point: "initial_and_temporal".into(),
zero_initialize_workgroup_memory: false,
entry_point: Some("initial_and_temporal".into()),
..default()
});
let spatial_and_shade_pipeline =
@ -232,9 +232,8 @@ impl FromWorld for SolariLightingNode {
range: 0..8,
}],
shader: load_embedded_asset!(world, "restir_di.wgsl"),
shader_defs: vec![],
entry_point: "spatial_and_shade".into(),
zero_initialize_workgroup_memory: false,
entry_point: Some("spatial_and_shade".into()),
..default()
});
Self {

8
crates/bevy_sprite/src/mesh2d/mesh.rs
View File

@ -52,6 +52,7 @@ use bevy_render::{
Extract, ExtractSchedule, Render, RenderApp, RenderSystems,
};
use bevy_transform::components::GlobalTransform;
use bevy_utils::default;
use nonmax::NonMaxU32;
use tracing::error;
@ -646,22 +647,21 @@ impl SpecializedMeshPipeline for Mesh2dPipeline {
Ok(RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_buffer_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend,
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone(), self.mesh_layout.clone()],
push_constant_ranges: vec![],
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
@ -693,7 +693,7 @@ impl SpecializedMeshPipeline for Mesh2dPipeline {
alpha_to_coverage_enabled: false,
},
label: Some(label.into()),
zero_initialize_workgroup_memory: false,
..default()
})
}
}

17
crates/bevy_sprite/src/render/mod.rs
View File

@ -40,6 +40,7 @@ use bevy_render::{
Extract,
};
use bevy_transform::components::GlobalTransform;
use bevy_utils::default;
use bytemuck::{Pod, Zeroable};
use fixedbitset::FixedBitSet;
@ -264,30 +265,21 @@ impl SpecializedRenderPipeline for SpritePipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![instance_rate_vertex_buffer_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone(), self.material_layout.clone()],
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
// Sprites are always alpha blended so they never need to write to depth.
// They just need to read it in case an opaque mesh2d
// that wrote to depth is present.
@ -313,8 +305,7 @@ impl SpecializedRenderPipeline for SpritePipeline {
alpha_to_coverage_enabled: false,
},
label: Some("sprite_pipeline".into()),
push_constant_ranges: Vec::new(),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

26
crates/bevy_ui/src/render/box_shadow.rs
View File

@ -2,6 +2,7 @@
use core::{hash::Hash, ops::Range};
use super::{stack_z_offsets, UiCameraMap, UiCameraView, QUAD_INDICES, QUAD_VERTEX_POSITIONS};
use crate::prelude::UiGlobalTransform;
use crate::{
BoxShadow, BoxShadowSamples, CalculatedClip, ComputedNode, ComputedNodeTarget, RenderUiSystems,
@ -30,10 +31,9 @@ use bevy_render::{
view::*,
Extract, ExtractSchedule, Render, RenderSystems,
};
use bevy_utils::default;
use bytemuck::{Pod, Zeroable};
use super::{stack_z_offsets, UiCameraMap, UiCameraView, QUAD_INDICES, QUAD_VERTEX_POSITIONS};
/// A plugin that enables the rendering of box shadows.
pub struct BoxShadowPlugin;
@ -167,14 +167,13 @@ impl SpecializedRenderPipeline for BoxShadowPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -184,26 +183,11 @@ impl SpecializedRenderPipeline for BoxShadowPipeline {
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone()],
push_constant_ranges: Vec::new(),
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
depth_stencil: None,
multisample: MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: Some("box_shadow_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

26
crates/bevy_ui/src/render/gradient.rs
View File

@ -4,6 +4,7 @@ use core::{
ops::Range,
};
use super::shader_flags::BORDER_ALL;
use crate::*;
use bevy_asset::*;
use bevy_color::{ColorToComponents, LinearRgba};
@ -30,10 +31,9 @@ use bevy_render::{
Extract, ExtractSchedule, Render, RenderSystems,
};
use bevy_sprite::BorderRect;
use bevy_utils::default;
use bytemuck::{Pod, Zeroable};
use super::shader_flags::BORDER_ALL;
pub struct GradientPlugin;
impl Plugin for GradientPlugin {
@ -198,14 +198,13 @@ impl SpecializedRenderPipeline for GradientPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -215,26 +214,11 @@ impl SpecializedRenderPipeline for GradientPipeline {
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone()],
push_constant_ranges: Vec::new(),
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
depth_stencil: None,
multisample: MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: Some("ui_gradient_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

23
crates/bevy_ui/src/render/pipeline.rs
View File

@ -9,6 +9,7 @@ use bevy_render::{
renderer::RenderDevice,
view::{ViewTarget, ViewUniform},
};
use bevy_utils::default;
#[derive(Resource)]
pub struct UiPipeline {
@ -88,14 +89,13 @@ impl SpecializedRenderPipeline for UiPipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -105,26 +105,11 @@ impl SpecializedRenderPipeline for UiPipeline {
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone(), self.image_layout.clone()],
push_constant_ranges: Vec::new(),
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
depth_stencil: None,
multisample: MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: Some("ui_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

24
crates/bevy_ui/src/render/ui_material_pipeline.rs
View File

@ -23,6 +23,7 @@ use bevy_render::{
Extract, ExtractSchedule, Render, RenderSystems,
};
use bevy_sprite::BorderRect;
use bevy_utils::default;
use bytemuck::{Pod, Zeroable};
use core::{hash::Hash, marker::PhantomData, ops::Range};
@ -152,14 +153,13 @@ where
let mut descriptor = RenderPipelineDescriptor {
vertex: VertexState {
shader: self.vertex_shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.fragment_shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -169,26 +169,10 @@ where
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![],
push_constant_ranges: Vec::new(),
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
depth_stencil: None,
multisample: MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: Some("ui_material_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
};
descriptor.layout = vec![self.view_layout.clone(), self.ui_layout.clone()];

23
crates/bevy_ui/src/render/ui_texture_slice_pipeline.rs
View File

@ -26,6 +26,7 @@ use bevy_render::{
Extract, ExtractSchedule, Render, RenderSystems,
};
use bevy_sprite::{SliceScaleMode, SpriteAssetEvents, SpriteImageMode, TextureSlicer};
use bevy_utils::default;
use binding_types::{sampler, texture_2d};
use bytemuck::{Pod, Zeroable};
use widget::ImageNode;
@ -175,14 +176,13 @@ impl SpecializedRenderPipeline for UiTextureSlicePipeline {
RenderPipelineDescriptor {
vertex: VertexState {
shader: self.shader.clone(),
entry_point: "vertex".into(),
shader_defs: shader_defs.clone(),
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs,
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: if key.hdr {
ViewTarget::TEXTURE_FORMAT_HDR
@ -192,26 +192,11 @@ impl SpecializedRenderPipeline for UiTextureSlicePipeline {
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
layout: vec![self.view_layout.clone(), self.image_layout.clone()],
push_constant_ranges: Vec::new(),
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: None,
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: PrimitiveTopology::TriangleList,
strip_index_format: None,
},
depth_stencil: None,
multisample: MultisampleState {
count: 1,
mask: !0,
alpha_to_coverage_enabled: false,
},
label: Some("ui_texture_slice_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

23
examples/2d/mesh2d_manual.rs
View File

@ -20,10 +20,10 @@ use bevy::{
},
render_resource::{
BlendState, ColorTargetState, ColorWrites, CompareFunction, DepthBiasState,
DepthStencilState, Face, FragmentState, FrontFace, MultisampleState, PipelineCache,
PolygonMode, PrimitiveState, PrimitiveTopology, RenderPipelineDescriptor,
SpecializedRenderPipeline, SpecializedRenderPipelines, StencilFaceState, StencilState,
TextureFormat, VertexBufferLayout, VertexFormat, VertexState, VertexStepMode,
DepthStencilState, Face, FragmentState, MultisampleState, PipelineCache,
PrimitiveState, PrimitiveTopology, RenderPipelineDescriptor, SpecializedRenderPipeline,
SpecializedRenderPipelines, StencilFaceState, StencilState, TextureFormat,
VertexBufferLayout, VertexFormat, VertexState, VertexStepMode,
},
sync_component::SyncComponentPlugin,
sync_world::{MainEntityHashMap, RenderEntity},
@ -165,21 +165,19 @@ impl SpecializedRenderPipeline for ColoredMesh2dPipeline {
vertex: VertexState {
// Use our custom shader
shader: COLORED_MESH2D_SHADER_HANDLE,
entry_point: "vertex".into(),
shader_defs: vec![],
// Use our custom vertex buffer
buffers: vec![vertex_layout],
..default()
},
fragment: Some(FragmentState {
// Use our custom shader
shader: COLORED_MESH2D_SHADER_HANDLE,
shader_defs: vec![],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
..default()
}),
// Use the two standard uniforms for 2d meshes
layout: vec![
@ -188,15 +186,10 @@ impl SpecializedRenderPipeline for ColoredMesh2dPipeline {
// Bind group 1 is the mesh uniform
self.mesh2d_pipeline.mesh_layout.clone(),
],
push_constant_ranges: vec![],
primitive: PrimitiveState {
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
unclipped_depth: false,
polygon_mode: PolygonMode::Fill,
conservative: false,
topology: key.primitive_topology(),
strip_index_format: None,
..default()
},
depth_stencil: Some(DepthStencilState {
format: CORE_2D_DEPTH_FORMAT,
@ -220,7 +213,7 @@ impl SpecializedRenderPipeline for ColoredMesh2dPipeline {
alpha_to_coverage_enabled: false,
},
label: Some("colored_mesh2d_pipeline".into()),
zero_initialize_workgroup_memory: false,
..default()
}
}
}

14
examples/shader/compute_shader_game_of_life.rs
View File

@ -173,22 +173,16 @@ impl FromWorld for GameOfLifePipeline {
let shader = world.load_asset(SHADER_ASSET_PATH);
let pipeline_cache = world.resource::<PipelineCache>();
let init_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: None,
layout: vec![texture_bind_group_layout.clone()],
push_constant_ranges: Vec::new(),
shader: shader.clone(),
shader_defs: vec![],
entry_point: Cow::from("init"),
zero_initialize_workgroup_memory: false,
entry_point: Some(Cow::from("init")),
..default()
});
let update_pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: None,
layout: vec![texture_bind_group_layout.clone()],
push_constant_ranges: Vec::new(),
shader,
shader_defs: vec![],
entry_point: Cow::from("update"),
zero_initialize_workgroup_memory: false,
entry_point: Some(Cow::from("update")),
..default()
});
GameOfLifePipeline {

24
examples/shader/custom_phase_item.rs
View File

@ -25,10 +25,10 @@ use bevy::{
},
render_resource::{
BufferUsages, Canonical, ColorTargetState, ColorWrites, CompareFunction,
DepthStencilState, FragmentState, GetBaseDescriptor, IndexFormat, MultisampleState,
PipelineCache, PrimitiveState, RawBufferVec, RenderPipeline, RenderPipelineDescriptor,
SpecializedCache, Specializer, SpecializerKey, TextureFormat, VertexAttribute,
VertexBufferLayout, VertexFormat, VertexState, VertexStepMode,
DepthStencilState, FragmentState, GetBaseDescriptor, IndexFormat, PipelineCache,
RawBufferVec, RenderPipeline, RenderPipelineDescriptor, SpecializedCache, Specializer,
SpecializerKey, TextureFormat, VertexAttribute, VertexBufferLayout, VertexFormat,
VertexState, VertexStepMode,
},
renderer::{RenderDevice, RenderQueue},
view::{self, ExtractedView, RenderVisibleEntities, VisibilityClass},
@ -311,12 +311,8 @@ impl GetBaseDescriptor<RenderPipeline> for CustomPhaseSpecializer {
fn get_base_descriptor(&self) -> RenderPipelineDescriptor {
RenderPipelineDescriptor {
label: Some("custom render pipeline".into()),
layout: vec![],
push_constant_ranges: vec![],
vertex: VertexState {
shader: self.shader.clone(),
shader_defs: vec![],
entry_point: "vertex".into(),
buffers: vec![VertexBufferLayout {
array_stride: size_of::<Vertex>() as u64,
step_mode: VertexStepMode::Vertex,
@ -334,11 +330,10 @@ impl GetBaseDescriptor<RenderPipeline> for CustomPhaseSpecializer {
},
],
}],
..default()
},
fragment: Some(FragmentState {
shader: self.shader.clone(),
shader_defs: vec![],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
// Ordinarily, you'd want to check whether the view has the
// HDR format and substitute the appropriate texture format
@ -347,8 +342,8 @@ impl GetBaseDescriptor<RenderPipeline> for CustomPhaseSpecializer {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState::default(),
// Note that if your view has no depth buffer this will need to be
// changed.
depth_stencil: Some(DepthStencilState {
@ -358,12 +353,7 @@ impl GetBaseDescriptor<RenderPipeline> for CustomPhaseSpecializer {
stencil: default(),
bias: default(),
}),
multisample: MultisampleState {
count: 0,
mask: !0,
alpha_to_coverage_enabled: false,
},
zero_initialize_workgroup_memory: false,
..default()
}
}
}

11
examples/shader/custom_post_processing.rs
View File

@ -264,23 +264,16 @@ fn setup_pipeline(
vertex: vertex_state,
fragment: Some(FragmentState {
shader,
shader_defs: vec![],
// Make sure this matches the entry point of your shader.
// It can be anything as long as it matches here and in the shader.
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::bevy_default(),
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
// All of the following properties are not important for this effect so just use the default values.
// This struct doesn't have the Default trait implemented because not all fields can have a default value.
primitive: PrimitiveState::default(),
depth_stencil: None,
multisample: MultisampleState::default(),
push_constant_ranges: vec![],
zero_initialize_workgroup_memory: false,
..default()
});
commands.insert_resource(PostProcessPipeline {
layout,

21
examples/shader/custom_render_phase.rs
View File

@ -47,10 +47,10 @@ use bevy::{
SortedRenderPhasePlugin, ViewSortedRenderPhases,
},
render_resource::{
CachedRenderPipelineId, ColorTargetState, ColorWrites, Face, FragmentState, FrontFace,
MultisampleState, PipelineCache, PolygonMode, PrimitiveState, RenderPassDescriptor,
RenderPipelineDescriptor, SpecializedMeshPipeline, SpecializedMeshPipelineError,
SpecializedMeshPipelines, TextureFormat, VertexState,
CachedRenderPipelineId, ColorTargetState, ColorWrites, Face, FragmentState,
PipelineCache, PrimitiveState, RenderPassDescriptor, RenderPipelineDescriptor,
SpecializedMeshPipeline, SpecializedMeshPipelineError, SpecializedMeshPipelines,
TextureFormat, VertexState,
},
renderer::RenderContext,
sync_world::MainEntity,
@ -209,35 +209,28 @@ impl SpecializedMeshPipeline for StencilPipeline {
// Bind group 2 is the mesh uniform
self.mesh_pipeline.mesh_layouts.model_only.clone(),
],
push_constant_ranges: vec![],
vertex: VertexState {
shader: self.shader_handle.clone(),
shader_defs: vec![],
entry_point: "vertex".into(),
buffers: vec![vertex_buffer_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader_handle.clone(),
shader_defs: vec![],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
format: TextureFormat::bevy_default(),
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState {
topology: key.primitive_topology(),
front_face: FrontFace::Ccw,
cull_mode: Some(Face::Back),
polygon_mode: PolygonMode::Fill,
..default()
},
depth_stencil: None,
// It's generally recommended to specialize your pipeline for MSAA,
// but it's not always possible
multisample: MultisampleState::default(),
zero_initialize_workgroup_memory: false,
..default()
})
}
}

5
examples/shader/gpu_readback.rs
View File

@ -176,11 +176,8 @@ impl FromWorld for ComputePipeline {
let pipeline = pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
label: Some("GPU readback compute shader".into()),
layout: vec![layout.clone()],
push_constant_ranges: Vec::new(),
shader: shader.clone(),
shader_defs: Vec::new(),
entry_point: "main".into(),
zero_initialize_workgroup_memory: false,
..default()
});
ComputePipeline { layout, pipeline }
}

22
examples/shader/shader_material_glsl.rs
View File

@ -1,15 +1,9 @@
//! A shader that uses the GLSL shading language.
use bevy::{
pbr::{MaterialPipeline, MaterialPipelineKey},
prelude::*,
reflect::TypePath,
render::{
mesh::MeshVertexBufferLayoutRef,
render_resource::{
AsBindGroup, RenderPipelineDescriptor, ShaderRef, SpecializedMeshPipelineError,
},
},
render::render_resource::{AsBindGroup, ShaderRef},
};
/// This example uses shader source files from the assets subdirectory
@ -74,18 +68,4 @@ impl Material for CustomMaterial {
fn alpha_mode(&self) -> AlphaMode {
self.alpha_mode
}
// Bevy assumes by default that vertex shaders use the "vertex" entry point
// and fragment shaders use the "fragment" entry point (for WGSL shaders).
// GLSL uses "main" as the entry point, so we must override the defaults here
fn specialize(
_pipeline: &MaterialPipeline,
descriptor: &mut RenderPipelineDescriptor,
_layout: &MeshVertexBufferLayoutRef,
_key: MaterialPipelineKey<Self>,
) -> Result<(), SpecializedMeshPipelineError> {
descriptor.vertex.entry_point = "main".into();
descriptor.fragment.as_mut().unwrap().entry_point = "main".into();
Ok(())
}
}

12
examples/shader/specialized_mesh_pipeline.rs
View File

@ -223,18 +223,14 @@ impl SpecializedMeshPipeline for CustomMeshPipeline {
view_layout.empty_layout.clone(),
self.mesh_pipeline.mesh_layouts.model_only.clone(),
],
push_constant_ranges: vec![],
vertex: VertexState {
shader: self.shader_handle.clone(),
shader_defs: vec![],
entry_point: "vertex".into(),
// Customize how to store the meshes' vertex attributes in the vertex buffer
buffers: vec![vertex_buffer_layout],
..default()
},
fragment: Some(FragmentState {
shader: self.shader_handle.clone(),
shader_defs: vec![],
entry_point: "fragment".into(),
targets: vec![Some(ColorTargetState {
// This isn't required, but bevy supports HDR and non-HDR rendering
// so it's generally recommended to specialize the pipeline for that
@ -248,6 +244,7 @@ impl SpecializedMeshPipeline for CustomMeshPipeline {
blend: None,
write_mask: ColorWrites::ALL,
})],
..default()
}),
primitive: PrimitiveState {
topology: mesh_key.primitive_topology(),
@ -269,9 +266,10 @@ impl SpecializedMeshPipeline for CustomMeshPipeline {
// but it's not always possible
multisample: MultisampleState {
count: mesh_key.msaa_samples(),
..MultisampleState::default()
..default()
},
zero_initialize_workgroup_memory: false,
..default()
})
}
}