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

render: Final cleanups

This commit is contained in:
relrelb 2021-03-20 16:30:21 +02:00 committed by Mike Welsh
parent c25b58058b
commit 648e14e057
4 changed files with 115 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
render/common_tess/src/lib.rs
View File

@ -5,11 +5,7 @@ use lyon::tessellation::{
FillTessellator, FillVertex, StrokeTessellator, StrokeVertex, StrokeVertexConstructor,
};
use lyon::tessellation::{FillOptions, StrokeOptions};
use ruffle_core::backend::render::{
srgb_to_linear,
swf::{self, FillStyle, GradientInterpolation, Twips},
BitmapHandle,
};
use ruffle_core::backend::render::{srgb_to_linear, swf, BitmapHandle};
use ruffle_core::shape_utils::{DistilledShape, DrawCommand, DrawPath};
pub struct ShapeTessellator {
@ -49,7 +45,7 @@ impl ShapeTessellator {
for path in shape.paths {
match path {
DrawPath::Fill { style, commands } => match style {
FillStyle::Color(color) => {
swf::FillStyle::Color(color) => {
let mut buffers_builder =
BuffersBuilder::new(&mut lyon_mesh, RuffleVertexCtor { color: *color });
@ -63,7 +59,7 @@ impl ShapeTessellator {
continue;
}
}
FillStyle::LinearGradient(gradient) => {
swf::FillStyle::LinearGradient(gradient) => {
flush_draw(DrawType::Color, &mut mesh, &mut lyon_mesh);
let mut buffers_builder = BuffersBuilder::new(
@ -93,7 +89,7 @@ impl ShapeTessellator {
&mut lyon_mesh,
);
}
FillStyle::RadialGradient(gradient) => {
swf::FillStyle::RadialGradient(gradient) => {
flush_draw(DrawType::Color, &mut mesh, &mut lyon_mesh);
let mut buffers_builder = BuffersBuilder::new(
@ -123,7 +119,7 @@ impl ShapeTessellator {
&mut lyon_mesh,
);
}
FillStyle::FocalGradient {
swf::FillStyle::FocalGradient {
gradient,
focal_point,
} => {
@ -156,7 +152,7 @@ impl ShapeTessellator {
&mut lyon_mesh,
);
}
FillStyle::Bitmap {
swf::FillStyle::Bitmap {
id,
matrix,
is_smoothed,
@ -296,9 +292,9 @@ pub struct Gradient {
pub ratios: Vec<f32>,
pub colors: Vec<[f32; 4]>,
pub num_colors: usize,
pub repeat_mode: GradientSpread,
pub repeat_mode: swf::GradientSpread,
pub focal_point: f32,
pub interpolation: GradientInterpolation,
pub interpolation: swf::GradientInterpolation,
}
#[derive(Clone, Debug)]
@ -367,12 +363,12 @@ fn swf_bitmap_to_gl_matrix(m: swf::Matrix, bitmap_width: u32, bitmap_height: u32
}
fn ruffle_path_to_lyon_path(commands: Vec<DrawCommand>, is_closed: bool) -> Path {
fn point(x: Twips, y: Twips) -> lyon::math::Point {
fn point(x: swf::Twips, y: swf::Twips) -> lyon::math::Point {
lyon::math::Point::new(x.to_pixels() as f32, y.to_pixels() as f32)
}
let mut builder = Path::builder();
let mut move_to = Some((Twips::default(), Twips::default()));
let mut move_to = Some((swf::Twips::default(), swf::Twips::default()));
for cmd in commands {
match cmd {
DrawCommand::MoveTo { x, y } => {
@ -472,8 +468,6 @@ impl StrokeVertexConstructor<Vertex> for RuffleVertexCtor {
}
}
pub use swf::GradientSpread;
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum GradientType {
Linear,

38
render/webgl/src/lib.rs
View File

@ -1,12 +1,11 @@
use ruffle_core::backend::render::swf;
use ruffle_core::backend::render::{
srgb_to_linear, Bitmap, BitmapFormat, BitmapHandle, BitmapInfo, Color, MovieLibrary,
RenderBackend, ShapeHandle, Transform,
Bitmap, BitmapFormat, BitmapHandle, BitmapInfo, Color, MovieLibrary, RenderBackend,
ShapeHandle, Transform,
};
use ruffle_core::shape_utils::DistilledShape;
use ruffle_core::swf::Matrix;
use ruffle_core::swf;
use ruffle_render_common_tess::{
Gradient as TessGradient, GradientSpread, GradientType, ShapeTessellator, Vertex,
Gradient as TessGradient, GradientType, ShapeTessellator, Vertex as TessVertex,
};
use ruffle_web_common::JsResult;
use std::collections::HashMap;
@ -36,13 +35,13 @@ enum MaskState {
#[derive(Clone, Debug)]
#[repr(C)]
struct GlVertex {
struct Vertex {
position: [f32; 2],
color: u32,
}
impl From<Vertex> for GlVertex {
fn from(vertex: Vertex) -> Self {
impl From<TessVertex> for Vertex {
fn from(vertex: TessVertex) -> Self {
Self {
position: [vertex.x, vertex.y],
color: ((vertex.color.a as u32) << 24)
@ -259,19 +258,19 @@ impl WebGlRenderBackend {
self.gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&vertex_buffer));
let verts = [
GlVertex {
Vertex {
position: [0.0, 0.0],
color: 0xffff_ffff,
},
GlVertex {
Vertex {
position: [1.0, 0.0],
color: 0xffff_ffff,
},
GlVertex {
Vertex {
position: [1.0, 1.0],
color: 0xffff_ffff,
},
GlVertex {
Vertex {
position: [0.0, 1.0],
color: 0xffff_ffff,
},
@ -513,11 +512,10 @@ impl WebGlRenderBackend {
self.gl.bind_buffer(Gl::ARRAY_BUFFER, Some(&vertex_buffer));
let (vertex_buffer, index_buffer) = unsafe {
let vertices: Vec<GlVertex> =
draw.vertices.into_iter().map(GlVertex::from).collect();
let vertices: Vec<_> = draw.vertices.into_iter().map(Vertex::from).collect();
let verts_bytes = std::slice::from_raw_parts(
vertices.as_ptr() as *const u8,
vertices.len() * std::mem::size_of::<GlVertex>(),
vertices.len() * std::mem::size_of::<Vertex>(),
);
self.gl
.buffer_data_with_u8_array(Gl::ARRAY_BUFFER, verts_bytes, Gl::STATIC_DRAW);
@ -954,7 +952,7 @@ impl RenderBackend for WebGlRenderBackend {
// Scale the quad to the bitmap's dimensions.
let matrix = transform.matrix
* Matrix {
* swf::Matrix {
a: width,
d: height,
..Default::default()
@ -1212,7 +1210,7 @@ impl RenderBackend for WebGlRenderBackend {
}
}
fn draw_rect(&mut self, color: Color, matrix: &Matrix) {
fn draw_rect(&mut self, color: Color, matrix: &swf::Matrix) {
let world_matrix = [
[matrix.a, matrix.b, 0.0, 0.0],
[matrix.c, matrix.d, 0.0, 0.0],
@ -1406,9 +1404,9 @@ impl From<TessGradient> for Gradient {
colors,
num_colors: gradient.num_colors as u32,
repeat_mode: match gradient.repeat_mode {
GradientSpread::Pad => 0,
GradientSpread::Repeat => 1,
GradientSpread::Reflect => 2,
swf::GradientSpread::Pad => 0,
swf::GradientSpread::Repeat => 1,
swf::GradientSpread::Reflect => 2,
},
focal_point: gradient.focal_point,
interpolation: gradient.interpolation,

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

@ -1,10 +1,10 @@
use ruffle_core::backend::render::{
swf, Bitmap, BitmapFormat, BitmapHandle, BitmapInfo, Color, MovieLibrary, RenderBackend,
Bitmap, BitmapFormat, BitmapHandle, BitmapInfo, Color, MovieLibrary, RenderBackend,
ShapeHandle, Transform,
};
use ruffle_core::shape_utils::DistilledShape;
use ruffle_core::swf;
use std::borrow::Cow;
use swf::{DefineBitsLossless, Glyph, GradientInterpolation};
use target::TextureTarget;
use bytemuck::{Pod, Zeroable};
@ -16,7 +16,10 @@ use crate::target::{RenderTarget, RenderTargetFrame, SwapChainTarget};
use crate::utils::{create_buffer_with_data, format_list, get_backend_names};
use enum_map::Enum;
use ruffle_core::color_transform::ColorTransform;
use ruffle_render_common_tess::{Gradient, GradientSpread, GradientType, ShapeTessellator, Vertex};
use ruffle_render_common_tess::{
DrawType as TessDrawType, Gradient as TessGradient, GradientType, ShapeTessellator,
Vertex as TessVertex,
};
type Error = Box<dyn std::error::Error>;
@ -33,7 +36,6 @@ pub mod clap;
use crate::bitmaps::BitmapSamplers;
use crate::globals::Globals;
use ruffle_core::swf::Matrix;
use std::collections::HashMap;
use std::path::Path;
pub use wgpu;
@ -157,13 +159,13 @@ impl From<ColorTransform> for ColorAdjustments {
#[repr(C)]
#[derive(Copy, Clone, Debug, Pod, Zeroable)]
struct GpuVertex {
struct Vertex {
position: [f32; 2],
color: [f32; 4],
}
impl From<Vertex> for GpuVertex {
fn from(vertex: Vertex) -> Self {
impl From<TessVertex> for Vertex {
fn from(vertex: TessVertex) -> Self {
Self {
position: [vertex.x, vertex.y],
color: [
@ -188,8 +190,8 @@ struct GradientUniforms {
focal_point: f32,
}
impl From<Gradient> for GradientUniforms {
fn from(gradient: Gradient) -> Self {
impl From<TessGradient> for GradientUniforms {
fn from(gradient: TessGradient) -> Self {
let mut ratios = [0.0; 16];
let mut colors = [[0.0; 4]; 16];
ratios[..gradient.num_colors].copy_from_slice(&gradient.ratios[..gradient.num_colors]);
@ -205,11 +207,11 @@ impl From<Gradient> for GradientUniforms {
},
num_colors: gradient.num_colors as u32,
repeat_mode: match gradient.repeat_mode {
GradientSpread::Pad => 0,
GradientSpread::Repeat => 1,
GradientSpread::Reflect => 2,
swf::GradientSpread::Pad => 0,
swf::GradientSpread::Repeat => 1,
swf::GradientSpread::Reflect => 2,
},
interpolation: (gradient.interpolation == GradientInterpolation::LinearRgb) as i32,
interpolation: (gradient.interpolation == swf::GradientInterpolation::LinearRgb) as i32,
focal_point: gradient.focal_point,
}
}
@ -413,7 +415,7 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
let mut draws = Vec::with_capacity(lyon_mesh.len());
for draw in lyon_mesh {
let vertices: Vec<GpuVertex> = draw.vertices.into_iter().map(GpuVertex::from).collect();
let vertices: Vec<_> = draw.vertices.into_iter().map(Vertex::from).collect();
let vertex_buffer = create_buffer_with_data(
&self.descriptors.device,
bytemuck::cast_slice(&vertices),
@ -431,8 +433,6 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
let index_count = draw.indices.len() as u32;
let draw_id = draws.len();
use ruffle_render_common_tess::DrawType as TessDrawType;
draws.push(match draw.draw_type {
TessDrawType::Color => Draw {
draw_type: DrawType::Color,
@ -474,32 +474,39 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
shape_id,
draw_id
);
let bind_group = self.descriptors.device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.descriptors.pipelines.gradient_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer {
buffer: &tex_transforms_ubo,
offset: 0,
size: wgpu::BufferSize::new(
std::mem::size_of::<TextureTransforms>() as u64,
),
},
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Buffer {
buffer: &gradient_ubo,
offset: 0,
size: wgpu::BufferSize::new(
std::mem::size_of::<GradientUniforms>() as u64,
),
},
},
],
label: bind_group_label.as_deref(),
});
let bind_group =
self.descriptors
.device
.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.descriptors.pipelines.gradient_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer {
buffer: &tex_transforms_ubo,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<
TextureTransforms,
>(
)
as u64),
},
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Buffer {
buffer: &gradient_ubo,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<
GradientUniforms,
>(
)
as u64),
},
},
],
label: bind_group_label.as_deref(),
});
Draw {
draw_type: DrawType::Gradient {
@ -538,26 +545,31 @@ impl<T: RenderTarget> WgpuRenderBackend<T> {
shape_id,
draw_id
);
let bind_group = self.descriptors.device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.descriptors.pipelines.bitmap_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer {
buffer: &tex_transforms_ubo,
offset: 0,
size: wgpu::BufferSize::new(
std::mem::size_of::<TextureTransforms>() as u64,
),
},
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&texture_view),
},
],
label: bind_group_label.as_deref(),
});
let bind_group =
self.descriptors
.device
.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.descriptors.pipelines.bitmap_layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer {
buffer: &tex_transforms_ubo,
offset: 0,
size: wgpu::BufferSize::new(std::mem::size_of::<
TextureTransforms,
>(
)
as u64),
},
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&texture_view),
},
],
label: bind_group_label.as_deref(),
});
Draw {
draw_type: DrawType::Bitmap {
@ -753,7 +765,7 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
self.meshes[handle.0] = mesh;
}
fn register_glyph_shape(&mut self, glyph: &Glyph) -> ShapeHandle {
fn register_glyph_shape(&mut self, glyph: &swf::Glyph) -> ShapeHandle {
let shape = ruffle_core::shape_utils::swf_glyph_to_shape(glyph);
let handle = ShapeHandle(self.meshes.len());
let mesh = self.register_shape_internal((&shape).into(), None);
@ -785,7 +797,10 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
Ok(self.register_bitmap(bitmap, "JPEG3"))
}
fn register_bitmap_png(&mut self, swf_tag: &DefineBitsLossless) -> Result<BitmapInfo, Error> {
fn register_bitmap_png(
&mut self,
swf_tag: &swf::DefineBitsLossless,
) -> Result<BitmapInfo, Error> {
let bitmap = ruffle_core::backend::render::decode_define_bits_lossless(swf_tag)?;
Ok(self.register_bitmap(bitmap, "PNG"))
}
@ -876,7 +891,7 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
let transform = Transform {
matrix: transform.matrix
* Matrix {
* swf::Matrix {
a: texture.width as f32,
d: texture.height as f32,
..Default::default()
@ -1051,7 +1066,7 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
}
}
fn draw_rect(&mut self, color: Color, matrix: &Matrix) {
fn draw_rect(&mut self, color: Color, matrix: &swf::Matrix) {
let frame = if let Some(frame) = &mut self.current_frame {
frame.get()
} else {
@ -1229,19 +1244,19 @@ impl<T: RenderTarget + 'static> RenderBackend for WgpuRenderBackend<T> {
fn create_quad_buffers(device: &wgpu::Device) -> (wgpu::Buffer, wgpu::Buffer, wgpu::Buffer) {
let vertices = [
GpuVertex {
Vertex {
position: [0.0, 0.0],
color: [1.0, 1.0, 1.0, 1.0],
},
GpuVertex {
Vertex {
position: [1.0, 0.0],
color: [1.0, 1.0, 1.0, 1.0],
},
GpuVertex {
Vertex {
position: [1.0, 1.0],
color: [1.0, 1.0, 1.0, 1.0],
},
GpuVertex {
Vertex {
position: [0.0, 1.0],
color: [1.0, 1.0, 1.0, 1.0],
},

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

@ -1,4 +1,4 @@
use crate::{Error, GpuVertex, MaskState};
use crate::{Error, MaskState, Vertex};
use enum_map::{enum_map, EnumMap};
use wgpu::vertex_attr_array;
@ -54,7 +54,7 @@ impl Pipelines {
let bitmap_fs = device.create_shader_module(&include_spirv!("../shaders/bitmap.frag.spv"));
let vertex_buffers_description = [wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<GpuVertex>() as u64,
array_stride: std::mem::size_of::<Vertex>() as u64,
step_mode: wgpu::InputStepMode::Vertex,
attributes: &vertex_attr_array![
0 => Float2,