liangsheng8708
/
ruffle
mirror of https://mirror.ghproxy.com/https://github.com/ruffle-rs/ruffle.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ruffle/render/wgpu/src/pipelines.rs

770 lines
31 KiB
Rust
Raw Normal View History

render: Final cleanups
2021-03-20 14:30:21 +00:00
use crate::{Error, MaskState, Vertex};
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
use enum_map::{enum_map, EnumMap};
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
use wgpu::vertex_attr_array;
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
#[derive(Debug)]
pub struct ShapePipeline {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
pub mask_pipelines: EnumMap<MaskState, wgpu::RenderPipeline>,
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
}
#[derive(Debug)]
pub struct Pipelines {
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
pub color_pipelines: ShapePipeline,
render: Split off common mesh binds into a mesh bind group for wgpu renderer
2020-10-17 21:39:24 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
pub bitmap_pipelines: ShapePipeline,
pub bitmap_layout: wgpu::BindGroupLayout,
render: Split off common mesh binds into a mesh bind group for wgpu renderer
2020-10-17 21:39:24 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
pub gradient_pipelines: ShapePipeline,
pub gradient_layout: wgpu::BindGroupLayout,
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
}
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
impl ShapePipeline {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
pub fn pipeline_for(&self, mask_state: MaskState) -> &wgpu::RenderPipeline {
&self.mask_pipelines[mask_state]
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
}
}
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
impl Pipelines {
render: Don't make a new sampler for each bitmap in wgpu renderer
2020-10-15 22:55:19 +00:00
pub fn new(
device: &wgpu::Device,
msaa_sample_count: u32,
sampler_layout: &wgpu::BindGroupLayout,
render: Store view_matrix as a global in wgpu renderer, and only change it when changed
2020-10-16 15:46:40 +00:00
globals_layout: &wgpu::BindGroupLayout,
render: Don't make a new sampler for each bitmap in wgpu renderer
2020-10-15 22:55:19 +00:00
) -> Result<Self, Error> {
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
// TODO: Naga validation errors when encountering push constants currently.
// Disable validation for now. Remove this when Naga can swallow it.
macro_rules! include_spirv {
($($token:tt)*) => {
{
wgpu::ShaderModuleDescriptor {
label: Some($($token)*),
source: wgpu::util::make_spirv(include_bytes!($($token)*)),
flags: wgpu::ShaderFlags::empty(),
}
}
};
}
let color_vs = device.create_shader_module(&include_spirv!("../shaders/color.vert.spv"));
let color_fs = device.create_shader_module(&include_spirv!("../shaders/color.frag.spv"));
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
let texture_vs =
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
device.create_shader_module(&include_spirv!("../shaders/texture.vert.spv"));
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
let gradient_fs =
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
device.create_shader_module(&include_spirv!("../shaders/gradient.frag.spv"));
let bitmap_fs = device.create_shader_module(&include_spirv!("../shaders/bitmap.frag.spv"));
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
let vertex_buffers_description = [wgpu::VertexBufferLayout {
render: Final cleanups
2021-03-20 14:30:21 +00:00
array_stride: std::mem::size_of::<Vertex>() as u64,
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
step_mode: wgpu::InputStepMode::Vertex,
attributes: &vertex_attr_array![
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
0 => Float32x2,
1 => Float32x4,
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
],
}];
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
let color_pipelines = create_color_pipelines(
&device,
&color_vs,
&color_fs,
msaa_sample_count,
&vertex_buffers_description,
globals_layout,
);
render: Split off common mesh binds into a mesh bind group for wgpu renderer
2020-10-17 21:39:24 +00:00
let bitmap_bind_layout_label = create_debug_label!("Bitmap shape bind group layout");
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
let bitmap_bind_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
chore: Update some dependencies * js-sys and wasm-bindgen are now the currently latest releases. * wgpu is not updated to the current master because it breaks things up.
2020-12-04 18:47:20 +00:00
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
chore: Update some dependencies * js-sys and wasm-bindgen are now the currently latest releases. * wgpu is not updated to the current master because it breaks things up.
2020-12-04 18:47:20 +00:00
ty: wgpu::BindingType::Texture {
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
multisampled: false,
chore: Update some dependencies * js-sys and wasm-bindgen are now the currently latest releases. * wgpu is not updated to the current master because it breaks things up.
2020-12-04 18:47:20 +00:00
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
},
count: None,
},
],
label: bitmap_bind_layout_label.as_deref(),
});
let bitmap_pipelines = create_bitmap_pipeline(
&device,
&texture_vs,
&bitmap_fs,
msaa_sample_count,
&vertex_buffers_description,
sampler_layout,
globals_layout,
&bitmap_bind_layout,
);
let gradient_bind_layout_label = create_debug_label!("Gradient shape bind group");
let gradient_bind_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
chore: Update some dependencies * js-sys and wasm-bindgen are now the currently latest releases. * wgpu is not updated to the current master because it breaks things up.
2020-12-04 18:47:20 +00:00
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
chore: Update some dependencies * js-sys and wasm-bindgen are now the currently latest releases. * wgpu is not updated to the current master because it breaks things up.
2020-12-04 18:47:20 +00:00
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
min_binding_size: None,
},
count: None,
},
],
label: gradient_bind_layout_label.as_deref(),
});
let gradient_pipelines = create_gradient_pipeline(
&device,
&texture_vs,
&gradient_fs,
msaa_sample_count,
&vertex_buffers_description,
globals_layout,
&gradient_bind_layout,
);
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
Ok(Self {
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
color_pipelines,
bitmap_pipelines,
bitmap_layout: bitmap_bind_layout,
gradient_pipelines,
gradient_layout: gradient_bind_layout,
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
})
}
}
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
#[allow(clippy::too_many_arguments)]
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
fn create_pipeline_descriptor<'a>(
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
label: Option<&'a str>,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
vertex_shader: &'a wgpu::ShaderModule,
fragment_shader: &'a wgpu::ShaderModule,
pipeline_layout: &'a wgpu::PipelineLayout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
depth_stencil_state: Option<wgpu::DepthStencilState>,
color_target_state: &'a [wgpu::ColorTargetState],
vertex_buffer_layout: &'a [wgpu::VertexBufferLayout<'a>],
wgpu: Add MSAA support (default to 4x for now)
2020-05-01 02:56:07 +00:00
msaa_sample_count: u32,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
) -> wgpu::RenderPipelineDescriptor<'a> {
wgpu::RenderPipelineDescriptor {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
label,
render: Update wgpu to 0.6
2020-08-27 10:32:41 +00:00
layout: Some(&pipeline_layout),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex: wgpu::VertexState {
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
module: &vertex_shader,
entry_point: "main",
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
buffers: vertex_buffer_layout,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
},
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
fragment: Some(wgpu::FragmentState {
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
module: &fragment_shader,
entry_point: "main",
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
targets: color_target_state,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
strip_index_format: None,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
front_face: wgpu::FrontFace::Ccw,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
cull_mode: None,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
polygon_mode: wgpu::PolygonMode::default(),
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
clamp_depth: false,
conservative: false,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
},
depth_stencil: depth_stencil_state,
multisample: wgpu::MultisampleState {
count: msaa_sample_count,
mask: !0,
alpha_to_coverage_enabled: false,
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
},
}
}
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
fn create_color_pipelines(
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
device: &wgpu::Device,
vertex_shader: &wgpu::ShaderModule,
fragment_shader: &wgpu::ShaderModule,
wgpu: Add MSAA support (default to 4x for now)
2020-05-01 02:56:07 +00:00
msaa_sample_count: u32,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_description: &[wgpu::VertexBufferLayout<'_>],
render: Store view_matrix as a global in wgpu renderer, and only change it when changed
2020-10-16 15:46:40 +00:00
globals_layout: &wgpu::BindGroupLayout,
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
) -> ShapePipeline {
wgpu: Use a single render pass and push constants Switch to a single render pass for the whole frame, as opposed to a render pass per draw call. This should be a large improvement to performance. This currently requires some unsafe to work around a self-reference between RenderPass and CommandEncoder in Frame; this could eventually be cleaned up by changing RenderBackend to return a Frame object instead of using begin_frame/end_frame pairs. Also switch to using push constants for the transform/color uniforms.
2020-12-26 00:43:03 +00:00
let transforms_size = std::mem::size_of::<crate::Transforms>() as u32;
let colors_size = std::mem::size_of::<crate::ColorAdjustments>() as u32;
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
let pipeline_layout_label = create_debug_label!("Color shape pipeline layout");
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
label: pipeline_layout_label.as_deref(),
wgpu: Use a single render pass and push constants Switch to a single render pass for the whole frame, as opposed to a render pass per draw call. This should be a large improvement to performance. This currently requires some unsafe to work around a self-reference between RenderPass and CommandEncoder in Frame; this could eventually be cleaned up by changing RenderBackend to return a Frame object instead of using begin_frame/end_frame pairs. Also switch to using push constants for the transform/color uniforms.
2020-12-26 00:43:03 +00:00
bind_group_layouts: &[globals_layout],
push_constant_ranges: &[
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::VERTEX,
range: 0..transforms_size,
},
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::FRAGMENT,
range: transforms_size..transforms_size + colors_size,
},
],
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
});
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
let mask_pipelines = enum_map! {
MaskState::NoMask => {
let (stencil, write_mask) = mask_render_state(MaskState::NoMask);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Color pipeline no mask").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
}
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
vertex_buffers_description,
msaa_sample_count,
))
},
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Color pipeline draw mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
vertex_buffers_description,
msaa_sample_count,
))
},
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskedContent => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskedContent);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Color pipeline draw masked content").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
vertex_buffers_description,
msaa_sample_count,
))
},
MaskState::ClearMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::ClearMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Color pipeline clear mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
vertex_buffers_description,
msaa_sample_count,
))
},
};
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
ShapePipeline { mask_pipelines }
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
}
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
#[allow(clippy::too_many_arguments)]
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
fn create_bitmap_pipeline(
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
device: &wgpu::Device,
vertex_shader: &wgpu::ShaderModule,
fragment_shader: &wgpu::ShaderModule,
wgpu: Add MSAA support (default to 4x for now)
2020-05-01 02:56:07 +00:00
msaa_sample_count: u32,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout: &[wgpu::VertexBufferLayout<'_>],
render: Don't make a new sampler for each bitmap in wgpu renderer
2020-10-15 22:55:19 +00:00
sampler_layout: &wgpu::BindGroupLayout,
render: Store view_matrix as a global in wgpu renderer, and only change it when changed
2020-10-16 15:46:40 +00:00
globals_layout: &wgpu::BindGroupLayout,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
bitmap_bind_layout: &wgpu::BindGroupLayout,
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
) -> ShapePipeline {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
let pipeline_layout_label = create_debug_label!("Bitmap shape pipeline layout");
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
label: pipeline_layout_label.as_deref(),
wgpu: Use a single render pass and push constants Switch to a single render pass for the whole frame, as opposed to a render pass per draw call. This should be a large improvement to performance. This currently requires some unsafe to work around a self-reference between RenderPass and CommandEncoder in Frame; this could eventually be cleaned up by changing RenderBackend to return a Frame object instead of using begin_frame/end_frame pairs. Also switch to using push constants for the transform/color uniforms.
2020-12-26 00:43:03 +00:00
bind_group_layouts: &[globals_layout, bitmap_bind_layout, sampler_layout],
push_constant_ranges: &[
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::VERTEX,
range: 0..64,
},
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::FRAGMENT,
range: 64..96,
},
render: Split off common mesh binds into a mesh bind group for wgpu renderer
2020-10-17 21:39:24 +00:00
],
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
});
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
let mask_pipelines = enum_map! {
MaskState::NoMask => {
let (stencil, write_mask) = mask_render_state(MaskState::NoMask);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Bitmap pipeline no mask").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Bitmap pipeline draw mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskedContent => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskedContent);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Bitmap pipeline draw masked content").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Equal,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
MaskState::ClearMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::ClearMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Bitmap pipeline clear mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
}
};
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
ShapePipeline { mask_pipelines }
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
}
render: Split off common mesh binds into a mesh bind group for wgpu renderer
2020-10-17 21:39:24 +00:00
#[allow(clippy::too_many_arguments)]
render: Add Pipelines struct to group together wgpu pipelines
2020-04-28 14:34:07 +00:00
fn create_gradient_pipeline(
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
device: &wgpu::Device,
vertex_shader: &wgpu::ShaderModule,
fragment_shader: &wgpu::ShaderModule,
wgpu: Add MSAA support (default to 4x for now)
2020-05-01 02:56:07 +00:00
msaa_sample_count: u32,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout: &[wgpu::VertexBufferLayout<'_>],
render: Store view_matrix as a global in wgpu renderer, and only change it when changed
2020-10-16 15:46:40 +00:00
globals_layout: &wgpu::BindGroupLayout,
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
gradient_bind_layout: &wgpu::BindGroupLayout,
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
) -> ShapePipeline {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
let pipeline_layout_label = create_debug_label!("Gradient shape pipeline layout");
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
render: Add more debug labels to wgpu renderer
2020-08-27 10:40:56 +00:00
label: pipeline_layout_label.as_deref(),
wgpu: Use a single render pass and push constants Switch to a single render pass for the whole frame, as opposed to a render pass per draw call. This should be a large improvement to performance. This currently requires some unsafe to work around a self-reference between RenderPass and CommandEncoder in Frame; this could eventually be cleaned up by changing RenderBackend to return a Frame object instead of using begin_frame/end_frame pairs. Also switch to using push constants for the transform/color uniforms.
2020-12-26 00:43:03 +00:00
bind_group_layouts: &[globals_layout, gradient_bind_layout],
push_constant_ranges: &[
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::VERTEX,
range: 0..64,
},
wgpu::PushConstantRange {
stages: wgpu::ShaderStage::FRAGMENT,
range: 64..96,
},
],
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
});
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
let mask_pipelines = enum_map! {
MaskState::NoMask => {
let (stencil, write_mask) = mask_render_state(MaskState::NoMask);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Gradient pipeline no mask").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Gradient pipeline draw mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
MaskState::DrawMaskedContent => {
let (stencil, write_mask) = mask_render_state(MaskState::DrawMaskedContent);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Gradient pipeline draw masked content").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Equal,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
},
MaskState::ClearMaskStencil => {
let (stencil, write_mask) = mask_render_state(MaskState::ClearMaskStencil);
device.create_render_pipeline(&create_pipeline_descriptor(
create_debug_label!("Gradient pipeline clear mask stencil").as_deref(),
vertex_shader,
fragment_shader,
&pipeline_layout,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
Some(wgpu::DepthStencilState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Depth24PlusStencil8,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Always,
stencil,
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
bias: Default::default(),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
}),
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
&[wgpu::ColorTargetState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
format: wgpu::TextureFormat::Bgra8Unorm,
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
blend: Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
write_mask,
}],
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
vertex_buffers_layout,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
msaa_sample_count,
))
}
};
render: Implement masks in wgpu renderer
2020-04-28 20:48:17 +00:00
render: Split up bind groups from pipelines for wgpu shapes in prep for them being refactored further
2020-10-17 19:05:16 +00:00
ShapePipeline { mask_pipelines }
render: Split off macros & pipeline creation from wgpu renderer
2020-04-28 14:10:45 +00:00
}
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
fn mask_render_state(state: MaskState) -> (wgpu::StencilState, wgpu::ColorWrite) {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
let (stencil_state, color_write) = match state {
MaskState::NoMask => (
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
wgpu::StencilFaceState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
compare: wgpu::CompareFunction::Always,
fail_op: wgpu::StencilOperation::Keep,
depth_fail_op: wgpu::StencilOperation::Keep,
pass_op: wgpu::StencilOperation::Keep,
},
wgpu::ColorWrite::ALL,
),
MaskState::DrawMaskStencil => (
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
wgpu::StencilFaceState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
compare: wgpu::CompareFunction::Equal,
fail_op: wgpu::StencilOperation::Keep,
depth_fail_op: wgpu::StencilOperation::Keep,
pass_op: wgpu::StencilOperation::IncrementClamp,
},
wgpu::ColorWrite::empty(),
),
MaskState::DrawMaskedContent => (
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
wgpu::StencilFaceState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
compare: wgpu::CompareFunction::Equal,
fail_op: wgpu::StencilOperation::Keep,
depth_fail_op: wgpu::StencilOperation::Keep,
pass_op: wgpu::StencilOperation::Keep,
},
wgpu::ColorWrite::ALL,
),
MaskState::ClearMaskStencil => (
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
wgpu::StencilFaceState {
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
compare: wgpu::CompareFunction::Equal,
fail_op: wgpu::StencilOperation::Keep,
depth_fail_op: wgpu::StencilOperation::Keep,
pass_op: wgpu::StencilOperation::DecrementClamp,
},
wgpu::ColorWrite::empty(),
),
};
(
chore: Bump to wgpu 0.70
2021-02-03 19:58:53 +00:00
wgpu::StencilState {
wgpu: Bump to latest wgpu master
2021-04-16 20:55:31 +00:00
front: stencil_state,
render: Fix masking issues on wgpu/webgl backends Change the usage of the stencil buffer to avoid running out of stencil bits when too many nested masks are active. This also cleans things up on wgpu which requires us to make pipeline states in advice; now we only need a few stencil states for masking as opposed to hundreds.
2020-10-14 18:25:55 +00:00
back: stencil_state,
read_mask: 0xff,
write_mask: 0xff,
},
color_write,
)
}