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: Separated srgb out of Surface

This commit is contained in:
Nathan Adams 2022-09-20 20:48:25 +02:00
parent 4502f9b7ea
commit 1df82e8104
5 changed files with 224 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
render/wgpu/src/backend.rs
View File

@ -1,9 +1,11 @@
use crate::context3d::WgpuContext3D;
use crate::mesh::{Draw, Mesh};
use crate::srgb::Srgb;
use crate::surface::Surface;
use crate::target::RenderTargetFrame;
use crate::target::TextureTarget;
use crate::uniform_buffer::BufferStorage;
use crate::utils::remove_srgb;
use crate::{
as_texture, format_list, get_backend_names, BufferDimensions, Descriptors, Error, Globals,
RenderTarget, SwapChainTarget, Texture, TextureOffscreen, Transforms,
@ -31,6 +33,7 @@ pub struct WgpuRenderBackend<T: RenderTarget> {
uniform_buffers_storage: BufferStorage<Transforms>,
target: T,
surface: Surface,
srgb: Option<Srgb>,
meshes: Vec<Mesh>,
shape_tessellator: ShapeTessellator,
// This is currently unused - we just store it to report in
@ -130,13 +133,29 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
.into());
}
// TODO: Allow the sample count to be set from command line/settings file.
let surface_format = target.format();
let frame_buffer_format = remove_srgb(surface_format);
let srgb = if surface_format != frame_buffer_format {
Some(Srgb::new(
&descriptors.device,
&descriptors.bind_layouts,
&descriptors.bitmap_samplers.get_sampler(false, false),
descriptors.copy_srgb_pipeline(surface_format),
&descriptors.quad,
frame_buffer_format,
target.width(),
target.height(),
))
} else {
None
};
let surface = Surface::new(
&descriptors,
DEFAULT_SAMPLE_COUNT,
target.width(),
target.height(),
target.format(),
frame_buffer_format,
);
let mut globals = Globals::new(&descriptors.device, &descriptors.bind_layouts.globals);
@ -151,6 +170,7 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
uniform_buffers_storage,
target,
surface,
srgb,
meshes: Vec::new(),
shape_tessellator: ShapeTessellator::new(),
viewport_scale_factor: 1.0,
@ -236,7 +256,25 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
1,
);
self.target.resize(&self.descriptors.device, width, height);
self.surface = Surface::new(&self.descriptors, 4, width, height, self.target.format());
let surface_format = self.target.format();
let frame_buffer_format = remove_srgb(surface_format);
if surface_format != frame_buffer_format {
self.srgb = Some(Srgb::new(
&self.descriptors.device,
&self.descriptors.bind_layouts,
&self.descriptors.bitmap_samplers.get_sampler(false, false),
self.descriptors.copy_srgb_pipeline(surface_format),
&self.descriptors.quad,
frame_buffer_format,
self.target.width(),
self.target.height(),
))
} else {
self.srgb = None;
}
self.surface = Surface::new(&self.descriptors, 4, width, height, frame_buffer_format);
self.globals.set_resolution(width, height);
self.viewport_scale_factor = dimensions.scale_factor;
@ -347,8 +385,12 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
}
};
let command_buffers = self.surface.draw_commands(
frame_output.view(),
let mut command_buffers = self.surface.draw_commands(
if let Some(srgb) = &self.srgb {
srgb.view()
} else {
frame_output.view()
},
Some(wgpu::Color {
r: f64::from(clear.r) / 255.0,
g: f64::from(clear.g) / 255.0,
@ -362,6 +404,14 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
commands,
);
if let Some(srgb) = &self.srgb {
command_buffers.push(srgb.copy_srgb(
frame_output.view(),
&self.descriptors,
&self.globals,
));
}
self.target.submit(
&self.descriptors.device,
&self.descriptors.queue,

10
render/wgpu/src/frame.rs
View File

@ -28,16 +28,6 @@ impl<'a> Frame<'a> {
}
}
pub fn prep_srgb_copy(
&mut self,
bind_group: &'a wgpu::BindGroup,
pipeline: &'a wgpu::RenderPipeline,
) {
self.render_pass.set_pipeline(&pipeline);
self.render_pass.set_bind_group(2, bind_group, &[]);
}
pub fn finish(self) {
self.uniform_buffers.finish()
}

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

@ -38,6 +38,7 @@ mod frame;
mod layouts;
mod mesh;
mod shaders;
mod srgb;
mod surface;
impl BitmapHandleImpl for Texture {}

154
render/wgpu/src/srgb.rs Normal file
View File

@ -0,0 +1,154 @@
use crate::layouts::BindLayouts;
use crate::{
create_buffer_with_data, ColorAdjustments, Descriptors, Globals, Quad, TextureTransforms,
Transforms,
};
use std::sync::Arc;
#[derive(Debug)]
pub struct Srgb {
view: wgpu::TextureView,
bind_group: wgpu::BindGroup,
copy_pipeline: Arc<wgpu::RenderPipeline>,
_transforms_buffer: wgpu::Buffer,
transforms_bind_group: wgpu::BindGroup,
}
impl Srgb {
#[allow(clippy::too_many_arguments)]
pub fn new(
device: &wgpu::Device,
layouts: &BindLayouts,
sampler: &wgpu::Sampler,
copy_pipeline: Arc<wgpu::RenderPipeline>,
quad: &Quad,
format: wgpu::TextureFormat,
width: u32,
height: u32,
) -> Self {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: create_debug_label!("Copy sRGB framebuffer texture").as_deref(),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
});
let view = texture.create_view(&Default::default());
let bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &layouts.bitmap,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &quad.texture_transforms,
offset: 0,
size: wgpu::BufferSize::new(
std::mem::size_of::<TextureTransforms>() as u64
),
}),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
label: create_debug_label!("Copy sRGB bind group").as_deref(),
});
let transform = Transforms {
world_matrix: [
[width as f32, 0.0, 0.0, 0.0],
[0.0, height as f32, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
],
color_adjustments: ColorAdjustments {
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(
&device,
bytemuck::cast_slice(&[transform]),
wgpu::BufferUsages::UNIFORM,
create_debug_label!("Copy sRGB transforms buffer"),
);
let transforms_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &layouts.transforms,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &transforms_buffer,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<Transforms>() as u64),
}),
}],
label: create_debug_label!("Copy sRGB transforms bind group").as_deref(),
});
Self {
view,
bind_group,
copy_pipeline,
_transforms_buffer: transforms_buffer,
transforms_bind_group,
}
}
pub fn copy_srgb(
&self,
view: &wgpu::TextureView,
descriptors: &Descriptors,
globals: &Globals,
) -> wgpu::CommandBuffer {
let mut copy_encoder =
descriptors
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: create_debug_label!("Frame copy command encoder").as_deref(),
});
let mut render_pass = copy_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: true,
},
resolve_target: None,
})],
depth_stencil_attachment: None,
label: None,
});
render_pass.set_pipeline(&&self.copy_pipeline);
render_pass.set_bind_group(0, globals.bind_group(), &[]);
render_pass.set_bind_group(1, &self.transforms_bind_group, &[0]);
render_pass.set_bind_group(2, &self.bind_group, &[]);
render_pass.set_vertex_buffer(0, descriptors.quad.vertices.slice(..));
render_pass.set_index_buffer(
descriptors.quad.indices.slice(..),
wgpu::IndexFormat::Uint32,
);
render_pass.draw_indexed(0..6, 0, 0..1);
drop(render_pass);
copy_encoder.finish()
}
pub fn view(&self) -> &wgpu::TextureView {
&self.view
}
}

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

@ -1,16 +1,8 @@
use crate::commands::CommandRenderer;
use crate::descriptors::Quad;
use crate::frame::Frame;
use crate::layouts::BindLayouts;
use crate::mesh::Mesh;
use crate::surface::Surface::{Direct, DirectSrgb, Resolve, ResolveSrgb};
use crate::uniform_buffer::BufferStorage;
use crate::utils::remove_srgb;
use crate::{
create_buffer_with_data, ColorAdjustments, Descriptors, Globals, Pipelines, TextureTransforms,
Transforms, UniformBuffer,
};
use crate::{Descriptors, Globals, Pipelines, Transforms, UniformBuffer};
use ruffle_render::commands::CommandList;
use std::sync::Arc;
@ -72,179 +64,17 @@ impl DepthTexture {
}
}
#[derive(Debug)]
pub struct Srgb {
view: wgpu::TextureView,
bind_group: wgpu::BindGroup,
copy_pipeline: Arc<wgpu::RenderPipeline>,
_transforms_buffer: wgpu::Buffer,
transforms_bind_group: wgpu::BindGroup,
}
impl Srgb {
#[allow(clippy::too_many_arguments)]
pub fn new(
device: &wgpu::Device,
layouts: &BindLayouts,
sampler: &wgpu::Sampler,
copy_pipeline: Arc<wgpu::RenderPipeline>,
quad: &Quad,
format: wgpu::TextureFormat,
width: u32,
height: u32,
) -> Self {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: create_debug_label!("Copy sRGB framebuffer texture").as_deref(),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
});
let view = texture.create_view(&Default::default());
let bind_group =
device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &layouts.bitmap,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &quad.texture_transforms,
offset: 0,
size: wgpu::BufferSize::new(
std::mem::size_of::<TextureTransforms>() as u64
),
}),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
label: create_debug_label!("Copy sRGB bind group").as_deref(),
});
let transform = Transforms {
world_matrix: [
[width as f32, 0.0, 0.0, 0.0],
[0.0, height as f32, 0.0, 0.0],
[0.0, 0.0, 1.0, 0.0],
[0.0, 0.0, 0.0, 1.0],
],
color_adjustments: ColorAdjustments {
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(
&device,
bytemuck::cast_slice(&[transform]),
wgpu::BufferUsages::UNIFORM,
create_debug_label!("Copy sRGB transforms buffer"),
);
let transforms_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &layouts.transforms,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &transforms_buffer,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<Transforms>() as u64),
}),
}],
label: create_debug_label!("Copy sRGB transforms bind group").as_deref(),
});
Self {
view,
bind_group,
copy_pipeline,
_transforms_buffer: transforms_buffer,
transforms_bind_group,
}
}
pub fn copy_srgb(
&self,
view: &wgpu::TextureView,
descriptors: &Descriptors,
globals: &Globals,
uniform_buffers_storage: &mut BufferStorage<Transforms>,
uniform_encoder: &mut wgpu::CommandEncoder,
pipelines: &Pipelines,
) -> wgpu::CommandBuffer {
let mut copy_encoder =
descriptors
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: create_debug_label!("Frame copy command encoder").as_deref(),
});
let mut srgb_render_pass = copy_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: true,
},
resolve_target: None,
})],
depth_stencil_attachment: None,
label: None,
});
srgb_render_pass.set_bind_group(0, globals.bind_group(), &[]);
srgb_render_pass.set_bind_group(1, &self.transforms_bind_group, &[0]);
let mut srgb_frame = Frame::new(
&pipelines,
&descriptors,
UniformBuffer::new(uniform_buffers_storage),
srgb_render_pass,
uniform_encoder,
);
srgb_frame.prep_srgb_copy(&self.bind_group, &self.copy_pipeline);
srgb_frame.draw(
descriptors.quad.vertices.slice(..),
descriptors.quad.indices.slice(..),
6,
);
drop(srgb_frame);
copy_encoder.finish()
}
}
#[derive(Debug)]
pub enum Surface {
Direct {
depth: DepthTexture,
pipelines: Arc<Pipelines>,
},
DirectSrgb {
srgb: Srgb,
depth: DepthTexture,
pipelines: Arc<Pipelines>,
},
Resolve {
frame_buffer: FrameBuffer,
depth: DepthTexture,
pipelines: Arc<Pipelines>,
},
ResolveSrgb {
frame_buffer: FrameBuffer,
srgb: Srgb,
depth: DepthTexture,
pipelines: Arc<Pipelines>,
},
}
impl Surface {
@ -253,10 +83,8 @@ impl Surface {
msaa_sample_count: u32,
width: u32,
height: u32,
surface_format: wgpu::TextureFormat,
frame_buffer_format: wgpu::TextureFormat,
) -> Self {
let frame_buffer_format = remove_srgb(surface_format);
let frame_buffer = if msaa_sample_count > 1 {
Some(FrameBuffer::new(
&descriptors.device,
@ -269,51 +97,23 @@ impl Surface {
None
};
let srgb = if surface_format != frame_buffer_format {
Some(Srgb::new(
&descriptors.device,
&descriptors.bind_layouts,
&descriptors.bitmap_samplers.get_sampler(false, false),
descriptors.copy_srgb_pipeline(surface_format),
&descriptors.quad,
frame_buffer_format,
width,
height,
))
} else {
None
};
let depth = DepthTexture::new(&descriptors.device, msaa_sample_count, width, height);
let pipelines = descriptors.pipelines(msaa_sample_count, frame_buffer_format);
match (frame_buffer, srgb) {
(Some(frame_buffer), None) => Resolve {
match frame_buffer {
Some(frame_buffer) => Surface::Resolve {
frame_buffer,
depth,
pipelines,
},
(None, None) => Direct { depth, pipelines },
(Some(frame_buffer), Some(srgb)) => ResolveSrgb {
frame_buffer,
depth,
srgb,
pipelines,
},
(None, Some(srgb)) => DirectSrgb {
depth,
srgb,
pipelines,
},
None => Surface::Direct { depth, pipelines },
}
}
pub fn view<'a>(&'a self, frame: &'a wgpu::TextureView) -> &wgpu::TextureView {
match self {
Direct { .. } => frame,
DirectSrgb { srgb, .. } => &srgb.view,
Resolve { frame_buffer, .. } => &frame_buffer.view,
ResolveSrgb { frame_buffer, .. } => &frame_buffer.view,
Surface::Direct { .. } => frame,
Surface::Resolve { frame_buffer, .. } => &frame_buffer.view,
}
}
@ -322,58 +122,22 @@ impl Surface {
frame: &'a wgpu::TextureView,
) -> Option<&wgpu::TextureView> {
match self {
Direct { .. } => None,
DirectSrgb { .. } => None,
Resolve { .. } => Some(&frame),
ResolveSrgb { srgb, .. } => Some(&srgb.view),
Surface::Direct { .. } => None,
Surface::Resolve { .. } => Some(&frame),
}
}
pub fn depth(&self) -> &wgpu::TextureView {
match self {
Direct { depth, .. } => &depth.view,
DirectSrgb { depth, .. } => &depth.view,
Resolve { depth, .. } => &depth.view,
ResolveSrgb { depth, .. } => &depth.view,
Surface::Direct { depth, .. } => &depth.view,
Surface::Resolve { depth, .. } => &depth.view,
}
}
pub fn pipelines(&self) -> &Pipelines {
match self {
Direct { pipelines, .. } => pipelines,
DirectSrgb { pipelines, .. } => pipelines,
Resolve { pipelines, .. } => pipelines,
ResolveSrgb { pipelines, .. } => pipelines,
}
}
pub fn copy_srgb(
&self,
frame: &wgpu::TextureView,
descriptors: &Descriptors,
globals: &Globals,
uniform_buffers_storage: &mut BufferStorage<Transforms>,
uniform_encoder: &mut wgpu::CommandEncoder,
) -> Option<wgpu::CommandBuffer> {
match self {
Direct { .. } => None,
DirectSrgb { srgb, .. } => Some(srgb.copy_srgb(
frame,
descriptors,
globals,
uniform_buffers_storage,
uniform_encoder,
self.pipelines(),
)),
Resolve { .. } => None,
ResolveSrgb { srgb, .. } => Some(srgb.copy_srgb(
frame,
descriptors,
globals,
uniform_buffers_storage,
uniform_encoder,
self.pipelines(),
)),
Surface::Direct { pipelines, .. } => pipelines,
Surface::Resolve { pipelines, .. } => pipelines,
}
}
@ -448,19 +212,6 @@ impl Surface {
));
frame.finish();
let copy_encoder = self.copy_srgb(
&frame_view,
&descriptors,
&globals,
uniform_buffers_storage,
&mut uniform_encoder,
);
let mut command_buffers = vec![uniform_encoder.finish(), draw_encoder.finish()];
if let Some(copy_encoder) = copy_encoder {
command_buffers.push(copy_encoder);
}
command_buffers
vec![uniform_encoder.finish(), draw_encoder.finish()]
}
}