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

wgpu: Merge Transforms and ColorAdjustments

This commit is contained in:
Nathan Adams 2024-01-23 22:06:44 +01:00
parent 1231d2fead
commit de975a9727
13 changed files with 42 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
render/wgpu/shaders/bitmap.wgsl
View File

@ -8,10 +8,9 @@ struct VertexOutput {
};
@group(1) @binding(0) var<uniform> transforms: common::Transforms;
@group(2) @binding(0) var<uniform> colorTransforms: common::ColorTransforms;
@group(3) @binding(0) var<uniform> textureTransforms: common::TextureTransforms;
@group(3) @binding(1) var texture: texture_2d<f32>;
@group(3) @binding(2) var texture_sampler: sampler;
@group(2) @binding(0) var<uniform> textureTransforms: common::TextureTransforms;
@group(2) @binding(1) var texture: texture_2d<f32>;
@group(2) @binding(2) var texture_sampler: sampler;
@vertex
fn main_vertex(in: common::VertexInput) -> VertexOutput {
@ -28,7 +27,7 @@ fn main_fragment(in: VertexOutput) -> @location(0) vec4<f32> {
// Unmultiply alpha, apply color transform, remultiply alpha.
if( color.a > 0.0 ) {
color = vec4<f32>(color.rgb / color.a, color.a);
color = color * colorTransforms.mult_color + colorTransforms.add_color;
color = color * transforms.mult_color + transforms.add_color;
#if early_saturate == true
color = saturate(color);
#endif

3
render/wgpu/shaders/color.wgsl
View File

@ -13,12 +13,11 @@ struct VertexOutput {
};
@group(1) @binding(0) var<uniform> transforms: common::Transforms;
@group(2) @binding(0) var<uniform> colorTransforms: common::ColorTransforms;
@vertex
fn main_vertex(in: VertexInput) -> VertexOutput {
let pos = common::globals.view_matrix * transforms.world_matrix * vec4<f32>(in.position.x, in.position.y, 0.0, 1.0);
let color = saturate(in.color * colorTransforms.mult_color + colorTransforms.add_color);
let color = saturate(in.color * transforms.mult_color + transforms.add_color);
return VertexOutput(pos, vec4<f32>(color.rgb * color.a, color.a));
}

8
render/wgpu/shaders/common.wgsl
View File

@ -13,10 +13,7 @@ struct Globals {
struct Transforms {
/// The world matrix that transforms this object into stage space.
world_matrix: mat4x4<f32>,
};
/// Transform uniforms that are changed per object.
struct ColorTransforms {
/// The multiplicative color transform of this object.
mult_color: vec4<f32>,
@ -31,11 +28,6 @@ struct TextureTransforms {
texture_matrix: mat4x4<f32>,
};
struct PushConstants {
transforms: Transforms,
colorTransforms: ColorTransforms,
}
/// The vertex format shared among most shaders.
struct VertexInput {
/// The position of the vertex in object space.

11
render/wgpu/shaders/gradient.wgsl
View File

@ -7,8 +7,7 @@ struct VertexOutput {
};
@group(1) @binding(0) var<uniform> transforms: common::Transforms;
@group(2) @binding(0) var<uniform> colorTransforms: common::ColorTransforms;
@group(3) @binding(0) var<uniform> textureTransforms: common::TextureTransforms;
@group(2) @binding(0) var<uniform> textureTransforms: common::TextureTransforms;
struct Gradient {
focal_point: f32,
@ -17,9 +16,9 @@ struct Gradient {
repeat: i32,
};
@group(3) @binding(1) var<uniform> gradient: Gradient;
@group(3) @binding(2) var texture: texture_2d<f32>;
@group(3) @binding(3) var texture_sampler: sampler;
@group(2) @binding(1) var<uniform> gradient: Gradient;
@group(2) @binding(2) var texture: texture_2d<f32>;
@group(2) @binding(3) var texture_sampler: sampler;
struct GradientVertexInput {
/// The position of the vertex in object space.
@ -79,7 +78,7 @@ fn main_fragment(in: VertexOutput) -> @location(0) vec4<f32> {
if( gradient.interpolation != 0 ) {
color = common::linear_to_srgb(color);
}
let out = saturate(color * colorTransforms.mult_color + colorTransforms.add_color);
let out = saturate(color * transforms.mult_color + transforms.add_color);
let alpha = saturate(out.a);
return vec4<f32>(out.rgb * alpha, alpha);
}

18
render/wgpu/src/descriptors.rs
View File

@ -4,7 +4,7 @@ use crate::pipelines::VERTEX_BUFFERS_DESCRIPTION_POS;
use crate::shaders::Shaders;
use crate::{
create_buffer_with_data, BitmapSamplers, Pipelines, PosColorVertex, PosVertex,
TextureTransforms, DEFAULT_COLOR_ADJUSTMENTS,
TextureTransforms,
};
use fnv::FnvHashMap;
use std::fmt::Debug;
@ -23,7 +23,6 @@ pub struct Descriptors {
copy_srgb_pipeline: Mutex<FnvHashMap<(u32, wgpu::TextureFormat), Arc<wgpu::RenderPipeline>>>,
pub shaders: Shaders,
pipelines: Mutex<FnvHashMap<(u32, wgpu::TextureFormat), Arc<Pipelines>>>,
pub default_color_bind_group: wgpu::BindGroup,
pub filters: Filters,
}
@ -45,20 +44,6 @@ impl Descriptors {
let bitmap_samplers = BitmapSamplers::new(&device);
let shaders = Shaders::new(&device);
let quad = Quad::new(&device);
let default_color_transform = create_buffer_with_data(
&device,
bytemuck::cast_slice(&[DEFAULT_COLOR_ADJUSTMENTS]),
wgpu::BufferUsages::UNIFORM,
create_debug_label!("Default colors"),
);
let default_color_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: create_debug_label!("Default colors").as_deref(),
layout: &bind_layouts.color_transforms,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: default_color_transform.as_entire_binding(),
}],
});
let filters = Filters::new(&device);
Self {
@ -74,7 +59,6 @@ impl Descriptors {
copy_srgb_pipeline: Default::default(),
shaders,
pipelines: Default::default(),
default_color_bind_group,
filters,
}
}

7
render/wgpu/src/dynamic_transforms.rs
View File

@ -1,5 +1,5 @@
use crate::descriptors::Descriptors;
use crate::{ColorAdjustments, Transforms};
use crate::Transforms;
use std::marker::PhantomData;
use std::mem;
@ -7,17 +7,12 @@ const ESTIMATED_OBJECTS_PER_CHUNK: u64 = 200;
pub struct DynamicTransforms {
pub transform: Inner<Transforms>,
pub color: Inner<ColorAdjustments>,
}
impl DynamicTransforms {
pub fn new(descriptors: &Descriptors) -> Self {
Self {
transform: Inner::new(&descriptors.device, &descriptors.bind_layouts.transforms),
color: Inner::new(
&descriptors.device,
&descriptors.bind_layouts.color_transforms,
),
}
}
}

20
render/wgpu/src/layouts.rs
View File

@ -1,11 +1,10 @@
use crate::globals::GlobalsUniform;
use crate::{ColorAdjustments, GradientUniforms, TextureTransforms, Transforms};
use crate::{GradientUniforms, TextureTransforms, Transforms};
#[derive(Debug)]
pub struct BindLayouts {
pub globals: wgpu::BindGroupLayout,
pub transforms: wgpu::BindGroupLayout,
pub color_transforms: wgpu::BindGroupLayout,
pub bitmap: wgpu::BindGroupLayout,
pub gradient: wgpu::BindGroupLayout,
pub blend: wgpu::BindGroupLayout,
@ -30,22 +29,6 @@ impl BindLayouts {
label: uniform_buffer_layout_label.as_deref(),
});
let color_transforms = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: wgpu::BufferSize::new(
std::mem::size_of::<ColorAdjustments>() as u64,
),
},
count: None,
}],
label: create_debug_label!("Color transforms bind group layout").as_deref(),
});
let globals_layout_label = create_debug_label!("Globals bind group layout");
let globals = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: globals_layout_label.as_deref(),
@ -181,7 +164,6 @@ impl BindLayouts {
Self {
globals,
transforms,
color_transforms,
bitmap,
gradient,
blend,

23
render/wgpu/src/lib.rs
View File

@ -73,6 +73,8 @@ pub enum MaskState {
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
pub struct Transforms {
world_matrix: [[f32; 4]; 4],
mult_color: [f32; 4],
add_color: [f32; 4],
}
#[repr(C)]
@ -81,27 +83,6 @@ struct TextureTransforms {
u_matrix: [[f32; 4]; 4],
}
#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable, PartialEq)]
pub struct ColorAdjustments {
mult_color: [f32; 4],
add_color: [f32; 4],
}
pub const DEFAULT_COLOR_ADJUSTMENTS: ColorAdjustments = ColorAdjustments {
mult_color: [1.0, 1.0, 1.0, 1.0],
add_color: [0.0, 0.0, 0.0, 0.0],
};
impl From<&swf::ColorTransform> for ColorAdjustments {
fn from(transform: &swf::ColorTransform) -> Self {
Self {
mult_color: transform.mult_rgba_normalized(),
add_color: transform.add_rgba_normalized(),
}
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
struct PosVertex {

8
render/wgpu/src/pipelines.rs
View File

@ -86,11 +86,7 @@ impl Pipelines {
msaa_sample_count: u32,
bind_layouts: &BindLayouts,
) -> Self {
let colort_bindings = vec![
&bind_layouts.globals,
&bind_layouts.transforms,
&bind_layouts.color_transforms,
];
let colort_bindings = vec![&bind_layouts.globals, &bind_layouts.transforms];
let color_pipelines = create_shape_pipeline(
"Color",
@ -107,7 +103,6 @@ impl Pipelines {
let gradient_bindings = vec![
&bind_layouts.globals,
&bind_layouts.transforms,
&bind_layouts.color_transforms,
&bind_layouts.gradient,
];
@ -146,7 +141,6 @@ impl Pipelines {
let bitmap_blend_bindings = vec![
&bind_layouts.globals,
&bind_layouts.transforms,
&bind_layouts.color_transforms,
&bind_layouts.bitmap,
];

8
render/wgpu/src/surface.rs
View File

@ -154,19 +154,13 @@ impl Surface {
for chunk in chunks {
match chunk {
Chunk::Draw(chunk, needs_stencil, transform_buffers, color_buffers) => {
Chunk::Draw(chunk, needs_stencil, transform_buffers) => {
transform_buffers.copy_to(
staging_belt,
&descriptors.device,
draw_encoder,
&dynamic_transforms.transform.buffer,
);
color_buffers.copy_to(
staging_belt,
&descriptors.device,
draw_encoder,
&dynamic_transforms.color.buffer,
);
let mut render_pass =
draw_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: create_debug_label!(

111
render/wgpu/src/surface/commands.rs
View File

@ -7,7 +7,7 @@ use crate::dynamic_transforms::DynamicTransforms;
use crate::mesh::{as_mesh, DrawType, Mesh};
use crate::surface::target::CommandTarget;
use crate::surface::Surface;
use crate::{as_texture, ColorAdjustments, Descriptors, MaskState, Pipelines, Transforms};
use crate::{as_texture, Descriptors, MaskState, Pipelines, Transforms};
use ruffle_render::backend::ShapeHandle;
use ruffle_render::bitmap::BitmapHandle;
use ruffle_render::commands::{Command, RenderBlendMode};
@ -71,14 +71,12 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
DrawCommand::RenderBitmap {
bitmap,
transform_buffer,
color_buffer,
smoothing,
blend_mode,
render_stage3d,
} => self.render_bitmap(
bitmap,
*transform_buffer,
*color_buffer,
*smoothing,
*blend_mode,
*render_stage3d,
@ -87,18 +85,13 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
_texture,
binds,
transform_buffer,
color_buffer,
blend_mode,
} => self.render_texture(*transform_buffer, *color_buffer, binds, *blend_mode),
} => self.render_texture(*transform_buffer, binds, *blend_mode),
DrawCommand::RenderShape {
shape,
transform_buffer,
color_buffer,
} => self.render_shape(shape, *transform_buffer, *color_buffer),
DrawCommand::DrawRect {
transform_buffer,
color_buffer,
} => self.draw_rect(*transform_buffer, *color_buffer),
} => self.render_shape(shape, *transform_buffer),
DrawCommand::DrawRect { transform_buffer } => self.draw_rect(*transform_buffer),
DrawCommand::PushMask => self.push_mask(),
DrawCommand::ActivateMask => self.activate_mask(),
DrawCommand::DeactivateMask => self.deactivate_mask(),
@ -125,7 +118,7 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
.set_pipeline(self.pipelines.gradients.stencilless_pipeline());
}
self.render_pass.set_bind_group(3, bind_group, &[]);
self.render_pass.set_bind_group(2, bind_group, &[]);
}
pub fn prep_bitmap(
@ -152,7 +145,7 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
}
}
self.render_pass.set_bind_group(3, bind_group, &[]);
self.render_pass.set_bind_group(2, bind_group, &[]);
}
pub fn draw(
@ -172,7 +165,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&mut self,
bitmap: &'frame BitmapHandle,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
smoothing: bool,
blend_mode: TrivialBlend,
render_stage3d: bool,
@ -198,11 +190,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&self.dynamic_transforms.transform.bind_group,
&[transform_buffer],
);
self.render_pass.set_bind_group(
2,
&self.dynamic_transforms.color.bind_group,
&[color_buffer],
);
self.draw(
self.descriptors.quad.vertices_pos.slice(..),
@ -217,7 +204,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
pub fn render_texture(
&mut self,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
bind_group: &'frame wgpu::BindGroup,
blend_mode: TrivialBlend,
) {
@ -231,11 +217,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&self.dynamic_transforms.transform.bind_group,
&[transform_buffer],
);
self.render_pass.set_bind_group(
2,
&self.dynamic_transforms.color.bind_group,
&[color_buffer],
);
self.draw(
self.descriptors.quad.vertices_pos.slice(..),
@ -251,7 +232,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&mut self,
shape: &'frame ShapeHandle,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
) {
if cfg!(feature = "render_debug_labels") {
self.render_pass.push_debug_group("render_shape");
@ -287,11 +267,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&self.dynamic_transforms.transform.bind_group,
&[transform_buffer],
);
self.render_pass.set_bind_group(
2,
&self.dynamic_transforms.color.bind_group,
&[color_buffer],
);
self.draw(
mesh.vertex_buffer.slice(draw.vertices.clone()),
@ -304,11 +279,7 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
}
}
pub fn draw_rect(
&mut self,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
) {
pub fn draw_rect(&mut self, transform_buffer: wgpu::DynamicOffset) {
if cfg!(feature = "render_debug_labels") {
self.render_pass.push_debug_group("draw_rect");
}
@ -319,11 +290,6 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
&self.dynamic_transforms.transform.bind_group,
&[transform_buffer],
);
self.render_pass.set_bind_group(
2,
&self.dynamic_transforms.color.bind_group,
&[color_buffer],
);
self.draw(
self.descriptors.quad.vertices_pos_color.slice(..),
@ -377,7 +343,7 @@ impl<'pass, 'frame: 'pass, 'global: 'frame> CommandRenderer<'pass, 'frame, 'glob
}
pub enum Chunk {
Draw(Vec<DrawCommand>, bool, BufferBuilder, BufferBuilder),
Draw(Vec<DrawCommand>, bool, BufferBuilder),
Blend(PoolOrArcTexture, ChunkBlendMode, bool),
}
@ -392,7 +358,6 @@ pub enum DrawCommand {
RenderBitmap {
bitmap: BitmapHandle,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
smoothing: bool,
blend_mode: TrivialBlend,
render_stage3d: bool,
@ -401,17 +366,14 @@ pub enum DrawCommand {
_texture: PoolOrArcTexture,
binds: wgpu::BindGroup,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
blend_mode: TrivialBlend,
},
RenderShape {
shape: ShapeHandle,
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
},
DrawRect {
transform_buffer: wgpu::DynamicOffset,
color_buffer: wgpu::DynamicOffset,
},
PushMask,
ActivateMask,
@ -448,22 +410,19 @@ pub fn chunk_blends<'a>(
let mut needs_stencil = false;
let mut num_masks = 0;
let mut transforms = BufferBuilder::new_for_uniform(&descriptors.limits);
let mut color_adjustments = BufferBuilder::new_for_uniform(&descriptors.limits);
transforms.set_buffer_limit(dynamic_transforms.transform.buffer.size());
color_adjustments.set_buffer_limit(dynamic_transforms.color.buffer.size());
fn add_to_current(
result: &mut Vec<Chunk>,
current: &mut Vec<DrawCommand>,
transforms: &mut BufferBuilder,
color_adjustments: &mut BufferBuilder,
dynamic_transforms: &DynamicTransforms,
needs_stencil: bool,
descriptors: &Descriptors,
matrix: Matrix,
color_transform: ColorTransform,
command_builder: impl FnOnce(wgpu::DynamicOffset, wgpu::DynamicOffset) -> DrawCommand,
command_builder: impl FnOnce(wgpu::DynamicOffset) -> DrawCommand,
) {
let transform = Transforms {
world_matrix: [
@ -477,15 +436,12 @@ pub fn chunk_blends<'a>(
1.0,
],
],
mult_color: color_transform.mult_rgba_normalized(),
add_color: color_transform.add_rgba_normalized(),
};
let color = ColorAdjustments::from(&color_transform);
if let (Ok(transform_range), Ok(color_range)) = (
transforms.add(&[transform]),
color_adjustments.add(&[color]),
) {
if let Ok(transform_range) = transforms.add(&[transform]) {
current.push(command_builder(
transform_range.start as wgpu::DynamicOffset,
color_range.start as wgpu::DynamicOffset,
));
} else {
result.push(Chunk::Draw(
@ -495,22 +451,13 @@ pub fn chunk_blends<'a>(
transforms,
BufferBuilder::new_for_uniform(&descriptors.limits),
),
std::mem::replace(
color_adjustments,
BufferBuilder::new_for_uniform(&descriptors.limits),
),
));
transforms.set_buffer_limit(dynamic_transforms.transform.buffer.size());
color_adjustments.set_buffer_limit(dynamic_transforms.color.buffer.size());
let transform_range = transforms
.add(&[transform])
.expect("Buffer must be able to fit a new thing, it was just emptied");
let color_range = color_adjustments
.add(&[color])
.expect("Buffer must be able to fit a new thing, it was just emptied");
current.push(command_builder(
transform_range.start as wgpu::DynamicOffset,
color_range.start as wgpu::DynamicOffset,
));
}
}
@ -587,17 +534,15 @@ pub fn chunk_blends<'a>(
&mut result,
&mut current,
&mut transforms,
&mut color_adjustments,
dynamic_transforms,
needs_stencil,
descriptors,
transform.matrix,
transform.color_transform,
|transform_buffer, color_buffer| DrawCommand::RenderTexture {
|transform_buffer| DrawCommand::RenderTexture {
_texture: texture,
binds: bind_group,
transform_buffer,
color_buffer,
blend_mode,
},
);
@ -611,14 +556,9 @@ pub fn chunk_blends<'a>(
&mut transforms,
BufferBuilder::new_for_uniform(&descriptors.limits),
),
std::mem::replace(
&mut color_adjustments,
BufferBuilder::new_for_uniform(&descriptors.limits),
),
));
}
transforms.set_buffer_limit(dynamic_transforms.transform.buffer.size());
color_adjustments.set_buffer_limit(dynamic_transforms.color.buffer.size());
let chunk_blend_mode = match blend_type {
BlendType::Complex(complex) => ChunkBlendMode::Complex(complex),
BlendType::Shader(shader) => ChunkBlendMode::Shader(shader),
@ -652,16 +592,14 @@ pub fn chunk_blends<'a>(
&mut result,
&mut current,
&mut transforms,
&mut color_adjustments,
dynamic_transforms,
needs_stencil,
descriptors,
matrix,
transform.color_transform,
|transform_buffer, color_buffer| DrawCommand::RenderBitmap {
|transform_buffer| DrawCommand::RenderBitmap {
bitmap,
transform_buffer,
color_buffer,
smoothing,
blend_mode: TrivialBlend::Normal,
render_stage3d: false,
@ -681,16 +619,14 @@ pub fn chunk_blends<'a>(
&mut result,
&mut current,
&mut transforms,
&mut color_adjustments,
dynamic_transforms,
needs_stencil,
descriptors,
matrix,
transform.color_transform,
|transform_buffer, color_buffer| DrawCommand::RenderBitmap {
|transform_buffer| DrawCommand::RenderBitmap {
bitmap,
transform_buffer,
color_buffer,
smoothing: false,
blend_mode: TrivialBlend::Normal,
render_stage3d: true,
@ -701,23 +637,20 @@ pub fn chunk_blends<'a>(
&mut result,
&mut current,
&mut transforms,
&mut color_adjustments,
dynamic_transforms,
needs_stencil,
descriptors,
transform.matrix,
transform.color_transform,
|transform_buffer, color_buffer| DrawCommand::RenderShape {
|transform_buffer| DrawCommand::RenderShape {
shape,
transform_buffer,
color_buffer,
},
),
Command::DrawRect { color, matrix } => add_to_current(
&mut result,
&mut current,
&mut transforms,
&mut color_adjustments,
dynamic_transforms,
needs_stencil,
descriptors,
@ -729,10 +662,7 @@ pub fn chunk_blends<'a>(
a_multiply: Fixed8::from_f32(f32::from(color.a) / 255.0),
..Default::default()
},
|transform_buffer, color_buffer| DrawCommand::DrawRect {
transform_buffer,
color_buffer,
},
|transform_buffer| DrawCommand::DrawRect { transform_buffer },
),
Command::PushMask => {
needs_stencil = true;
@ -756,12 +686,7 @@ pub fn chunk_blends<'a>(
}
if !current.is_empty() {
result.push(Chunk::Draw(
current,
needs_stencil,
transforms,
color_adjustments,
));
result.push(Chunk::Draw(current, needs_stencil, transforms));
}
result

2
render/wgpu/src/surface/target.rs
View File

@ -469,6 +469,8 @@ fn get_whole_frame_bind_group<'a>(
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
],
mult_color: [1.0, 1.0, 1.0, 1.0],
add_color: [0.0, 0.0, 0.0, 0.0],
};
let transforms_buffer = create_buffer_with_data(
&descriptors.device,

27
render/wgpu/uniforms.md
View File

@ -28,17 +28,11 @@ These should be set for the whole render pass and be immutable during it.
## Group 1: Mesh transforms
These should be set for the current mesh being rendered.
| Index | Type | Description | Availability |
|:-----:|---------|:------------------|--------------|
| 0 | uniform | World matrix | Vertex |
| Index | Type | Description | Availability |
|:-----:|---------|:----------------------------------|--------------|
| 0 | uniform | World matrix and color transforms | Vertex |
# Bitmaps
## Group 2: Color transforms
| Index | Type | Description | Availability |
|:-----:|------------|:-------------------------------------|--------------|
| 0 | uniform | Color adjustments | Fragment |
## Group 3: Texture transforms
## Group 2: Texture transforms
| Index | Type | Description | Availability |
|:-----:|------------|:-------------------------------------|--------------|
| 0 | uniform | Transformation matrix of the texture | Vertex |
@ -46,12 +40,7 @@ These should be set for the current mesh being rendered.
| 2 | sampler | Sampler used for the texture | Fragment |
# Gradient
## Group 2: Color transforms
| Index | Type | Description | Availability |
|:-----:|------------|:-------------------------------------|--------------|
| 0 | uniform | Color adjustments | Fragment |
## Group 3: Texture transforms
## Group 2: Texture transforms
Index 1 is a storage buffer when supported by the device, or a uniform buffer otherwise.
Storage buffers are more efficient and waste less memory, but are not as widely supported (ie WebGL)
@ -59,9 +48,3 @@ Storage buffers are more efficient and waste less memory, but are not as widely
|:-----:|--------------------|:--------------------------------------|--------------|
| 0 | uniform | Transformation matrix of the gradient | Vertex |
| 1 | uniform or storage | Gradient information, colors etc | Fragment |
# Color
## Group 2: Color transforms
| Index | Type | Description | Availability |
|:-----:|------------|:-------------------------------------|--------------|
| 0 | uniform | Color adjustments | Fragment |