From a90a5cba08fdf6c0ceb95101c275108a152a3aed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 12 Jun 2024 07:35:37 +0200 Subject: Merging upstream version 127.0. Signed-off-by: Daniel Baumann --- gfx/wr/wrench/src/yaml_frame_reader.rs | 1 + gfx/wr/wrench/src/yaml_helper.rs | 330 +++++++++++++++++++++++++++++++++ 2 files changed, 331 insertions(+) (limited to 'gfx/wr/wrench/src') diff --git a/gfx/wr/wrench/src/yaml_frame_reader.rs b/gfx/wr/wrench/src/yaml_frame_reader.rs index e67e749d56..0afe3968ee 100644 --- a/gfx/wr/wrench/src/yaml_frame_reader.rs +++ b/gfx/wr/wrench/src/yaml_frame_reader.rs @@ -1685,6 +1685,7 @@ impl YamlFrameReader { yaml["horizontal-offset-bounds"].as_sticky_offset_bounds(), yaml["previously-applied-offset"].as_vector().unwrap_or_else(LayoutVector2D::zero), self.next_spatial_key(), + None, ); if let Some(numeric_id) = numeric_id { diff --git a/gfx/wr/wrench/src/yaml_helper.rs b/gfx/wr/wrench/src/yaml_helper.rs index c28fad04ce..793c8e6023 100644 --- a/gfx/wr/wrench/src/yaml_helper.rs +++ b/gfx/wr/wrench/src/yaml_helper.rs @@ -9,6 +9,7 @@ use std::str::FromStr; use webrender::api::*; use webrender::api::units::*; use yaml_rust::{Yaml, YamlLoader}; +use log::Level; pub trait YamlHelper { fn as_f32(&self) -> Option; @@ -33,6 +34,7 @@ pub trait YamlHelper { fn as_transform_style(&self) -> Option; fn as_raster_space(&self) -> Option; fn as_clip_mode(&self) -> Option; + fn as_graph_picture_reference(&self) -> Option; fn as_mix_blend_mode(&self) -> Option; fn as_filter_op(&self) -> Option; fn as_vec_filter_op(&self) -> Option>; @@ -537,7 +539,335 @@ impl YamlHelper for Yaml { self.as_str().and_then(StringEnum::from_str) } + fn as_graph_picture_reference(&self) -> Option { + match self.as_i64() { + Some(n) => Some(FilterOpGraphPictureReference{ + buffer_id: FilterOpGraphPictureBufferId::BufferId(n as i16), + }), + None => None, + } + } + fn as_filter_op(&self) -> Option { + if let Some(filter_op) = self["svgfe"].as_str() { + let subregion = self["subregion"].as_rect().unwrap_or( + LayoutRect::new( + LayoutPoint::new(0.0, 0.0), + LayoutPoint::new(1024.0, 1024.0), + )); + + let node = FilterOpGraphNode { + linear: self["linear"].as_bool().unwrap_or(true), + subregion, + input: self["in"].as_graph_picture_reference().unwrap_or( + FilterOpGraphPictureReference{ + buffer_id: FilterOpGraphPictureBufferId::None, + }), + input2: self["in2"].as_graph_picture_reference().unwrap_or( + FilterOpGraphPictureReference{ + buffer_id: FilterOpGraphPictureBufferId::None, + }), + }; + let debug_print_input = |input: FilterOpGraphPictureReference| -> String { + match input.buffer_id { + FilterOpGraphPictureBufferId::BufferId(id) => format!("BufferId{}", id), + FilterOpGraphPictureBufferId::None => "None".into(), + } + }; + log!(Level::Debug, "svgfe parsed: {} linear: {} in: {} in2: {} subregion: [{}, {}, {}, {}]", + filter_op, node.linear, + debug_print_input(node.input), debug_print_input(node.input2), + node.subregion.min.x, node.subregion.min.y, node.subregion.max.x, node.subregion.max.y, + ); + return match filter_op { + "identity" => Some(FilterOp::SVGFEIdentity{node}), + "opacity" => { + let value = self["value"].as_f32().unwrap(); + Some(FilterOp::SVGFEOpacity{node, valuebinding: value.into(), value}) + }, + "toalpha" => Some(FilterOp::SVGFEToAlpha{node}), + "blendcolor" => Some(FilterOp::SVGFEBlendColor{node}), + "blendcolorburn" => Some(FilterOp::SVGFEBlendColorBurn{node}), + "blendcolordodge" => Some(FilterOp::SVGFEBlendColorDodge{node}), + "blenddarken" => Some(FilterOp::SVGFEBlendDarken{node}), + "blenddifference" => Some(FilterOp::SVGFEBlendDifference{node}), + "blendexclusion" => Some(FilterOp::SVGFEBlendExclusion{node}), + "blendhardlight" => Some(FilterOp::SVGFEBlendHardLight{node}), + "blendhue" => Some(FilterOp::SVGFEBlendHue{node}), + "blendlighten" => Some(FilterOp::SVGFEBlendLighten{node}), + "blendluminosity" => Some(FilterOp::SVGFEBlendLuminosity{node}), + "blendmultiply" => Some(FilterOp::SVGFEBlendMultiply{node}), + "blendnormal" => Some(FilterOp::SVGFEBlendNormal{node}), + "blendoverlay" => Some(FilterOp::SVGFEBlendOverlay{node}), + "blendsaturation" => Some(FilterOp::SVGFEBlendSaturation{node}), + "blendscreen" => Some(FilterOp::SVGFEBlendScreen{node}), + "blendsoftlight" => Some(FilterOp::SVGFEBlendSoftLight{node}), + "colormatrix" => { + let m: Vec = self["matrix"].as_vec_f32().unwrap(); + let mut matrix: [f32; 20] = [0.0; 20]; + matrix.clone_from_slice(&m); + Some(FilterOp::SVGFEColorMatrix{node, values: matrix}) + } + "componenttransfer" => Some(FilterOp::SVGFEComponentTransfer{node}), + "compositearithmetic" => { + let k: Vec = self["k"].as_vec_f32().unwrap(); + Some(FilterOp::SVGFECompositeArithmetic{ + node, + k1: k[0], + k2: k[1], + k3: k[2], + k4: k[3], + }) + } + "compositeatop" => Some(FilterOp::SVGFECompositeATop{node}), + "compositein" => Some(FilterOp::SVGFECompositeIn{node}), + "compositelighter" => Some(FilterOp::SVGFECompositeLighter{node}), + "compositeout" => Some(FilterOp::SVGFECompositeOut{node}), + "compositeover" => Some(FilterOp::SVGFECompositeOver{node}), + "compositexor" => Some(FilterOp::SVGFECompositeXOR{node}), + "convolvematrixedgemodeduplicate" => { + let order_x = self["order_x"].as_i64().unwrap() as i32; + let order_y = self["order_y"].as_i64().unwrap() as i32; + let m: Vec = self["kernel"].as_vec_f32().unwrap(); + let mut kernel: [f32; 25] = [0.0; 25]; + kernel.clone_from_slice(&m); + let divisor = self["divisor"].as_f32().unwrap(); + let bias = self["bias"].as_f32().unwrap(); + let target_x = self["target_x"].as_i64().unwrap() as i32; + let target_y = self["target_y"].as_i64().unwrap() as i32; + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let preserve_alpha = match self["preserve_alpha"].as_bool() { + Some(true) => 1, + Some(false) => 0, + _ => 1, + }; + Some(FilterOp::SVGFEConvolveMatrixEdgeModeDuplicate{ + node, order_x, order_y, kernel, divisor, bias, + target_x, target_y, kernel_unit_length_x, + kernel_unit_length_y, preserve_alpha}) + }, + "convolvematrixedgemodenone" => { + let order_x = self["order_x"].as_i64().unwrap() as i32; + let order_y = self["order_y"].as_i64().unwrap() as i32; + let m: Vec = self["kernel"].as_vec_f32().unwrap(); + let mut kernel: [f32; 25] = [0.0; 25]; + kernel.clone_from_slice(&m); + let divisor = self["divisor"].as_f32().unwrap(); + let bias = self["bias"].as_f32().unwrap(); + let target_x = self["target_x"].as_i64().unwrap() as i32; + let target_y = self["target_y"].as_i64().unwrap() as i32; + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let preserve_alpha = match self["preserve_alpha"].as_bool() { + Some(true) => 1, + Some(false) => 0, + _ => 1, + }; + Some(FilterOp::SVGFEConvolveMatrixEdgeModeNone{ + node, order_x, order_y, kernel, divisor, bias, + target_x, target_y, kernel_unit_length_x, + kernel_unit_length_y, preserve_alpha}) + }, + "convolvematrixedgemodewrap" => { + let order_x = self["order_x"].as_i64().unwrap() as i32; + let order_y = self["order_y"].as_i64().unwrap() as i32; + let m: Vec = self["kernel"].as_vec_f32().unwrap(); + let mut kernel: [f32; 25] = [0.0; 25]; + kernel.clone_from_slice(&m); + let divisor = self["divisor"].as_f32().unwrap(); + let bias = self["bias"].as_f32().unwrap(); + let target_x = self["target_x"].as_i64().unwrap() as i32; + let target_y = self["target_y"].as_i64().unwrap() as i32; + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let preserve_alpha = match self["preserve_alpha"].as_bool() { + Some(true) => 1, + Some(false) => 0, + _ => 1, + }; + Some(FilterOp::SVGFEConvolveMatrixEdgeModeWrap{ + node, order_x, order_y, kernel, divisor, bias, + target_x, target_y, kernel_unit_length_x, + kernel_unit_length_y, preserve_alpha}) + }, + "diffuselightingdistant" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let diffuse_constant = self["diffuse_constant"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let azimuth = self["azimuth"].as_f32().unwrap(); + let elevation = self["elevation"].as_f32().unwrap(); + Some(FilterOp::SVGFEDiffuseLightingDistant{ + node, surface_scale, diffuse_constant, + kernel_unit_length_x, kernel_unit_length_y, + azimuth, elevation}) + }, + "diffuselightingpoint" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let diffuse_constant = self["diffuse_constant"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let x = self["x"].as_f32().unwrap(); + let y = self["y"].as_f32().unwrap(); + let z = self["z"].as_f32().unwrap(); + Some(FilterOp::SVGFEDiffuseLightingPoint{ + node, surface_scale, diffuse_constant, + kernel_unit_length_x, kernel_unit_length_y, x, y, z}) + }, + "diffuselightingspot" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let diffuse_constant = self["diffuse_constant"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let x = self["x"].as_f32().unwrap(); + let y = self["y"].as_f32().unwrap(); + let z = self["z"].as_f32().unwrap(); + let points_at_x = self["points_at_x"].as_f32().unwrap(); + let points_at_y = self["points_at_y"].as_f32().unwrap(); + let points_at_z = self["points_at_z"].as_f32().unwrap(); + let cone_exponent = self["cone_exponent"].as_f32().unwrap(); + let limiting_cone_angle = self["limiting_cone_angle"].as_f32().unwrap(); + Some(FilterOp::SVGFEDiffuseLightingSpot{ + node, surface_scale, diffuse_constant, + kernel_unit_length_x, kernel_unit_length_y, x, y, z, + points_at_x, points_at_y, points_at_z, cone_exponent, + limiting_cone_angle}) + }, + "displacementmap" => { + let scale = self["scale"].as_f32().unwrap(); + let x_channel_selector = self["x_channel_selector"].as_i64().unwrap() as u32; + let y_channel_selector = self["y_channel_selector"].as_i64().unwrap() as u32; + Some(FilterOp::SVGFEDisplacementMap{node, scale, x_channel_selector, y_channel_selector}) + }, + "dropshadow" => { + let color = self["color"].as_colorf().unwrap(); + let dx = self["dx"].as_f32().unwrap(); + let dy = self["dy"].as_f32().unwrap(); + let std_deviation_x = self["std_deviation_x"].as_f32().unwrap(); + let std_deviation_y = self["std_deviation_y"].as_f32().unwrap(); + Some(FilterOp::SVGFEDropShadow{node, color, dx, dy, std_deviation_x, std_deviation_y}) + }, + "flood" => Some(FilterOp::SVGFEFlood{node, color: self["color"].as_colorf().unwrap()}), + "gaussianblur" => { + let std_deviation_x = self["std_deviation_x"].as_f32().unwrap(); + let std_deviation_y = self["std_deviation_y"].as_f32().unwrap(); + Some(FilterOp::SVGFEGaussianBlur{node, std_deviation_x, std_deviation_y}) + }, + "image" => { + let sampling_filter = match self["sampling_filter"].as_str() { + Some("GOOD") => 0, + Some("LINEAR") => 1, + Some("POINT") => 2, + _ => 0, + }; + let m: Vec = self["matrix"].as_vec_f32().unwrap(); + let mut matrix: [f32; 6] = [0.0; 6]; + matrix.clone_from_slice(&m); + Some(FilterOp::SVGFEImage{node, sampling_filter, matrix}) + }, + "morphologydilate" => { + let radius_x = self["radius_x"].as_f32().unwrap(); + let radius_y = self["radius_y"].as_f32().unwrap(); + Some(FilterOp::SVGFEMorphologyDilate{node, radius_x, radius_y}) + }, + "morphologyerode" => { + let radius_x = self["radius_x"].as_f32().unwrap(); + let radius_y = self["radius_y"].as_f32().unwrap(); + Some(FilterOp::SVGFEMorphologyErode{node, radius_x, radius_y}) + }, + "offset" => { + let offset = self["offset"].as_vec_f32().unwrap(); + Some(FilterOp::SVGFEOffset{node, offset_x: offset[0], offset_y: offset[1]}) + }, + "SourceAlpha" => Some(FilterOp::SVGFESourceAlpha{node}), + "SourceGraphic" => Some(FilterOp::SVGFESourceGraphic{node}), + "sourcealpha" => Some(FilterOp::SVGFESourceAlpha{node}), + "sourcegraphic" => Some(FilterOp::SVGFESourceGraphic{node}), + "specularlightingdistant" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let specular_constant = self["specular_constant"].as_f32().unwrap(); + let specular_exponent = self["specular_exponent"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let azimuth = self["azimuth"].as_f32().unwrap(); + let elevation = self["elevation"].as_f32().unwrap(); + Some(FilterOp::SVGFESpecularLightingDistant{ + node, surface_scale, specular_constant, + specular_exponent, kernel_unit_length_x, + kernel_unit_length_y, azimuth, elevation}) + }, + "specularlightingpoint" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let specular_constant = self["specular_constant"].as_f32().unwrap(); + let specular_exponent = self["specular_exponent"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let x = self["x"].as_f32().unwrap(); + let y = self["y"].as_f32().unwrap(); + let z = self["z"].as_f32().unwrap(); + Some(FilterOp::SVGFESpecularLightingPoint{ + node, surface_scale, specular_constant, + specular_exponent, kernel_unit_length_x, + kernel_unit_length_y, x, y, z}) + }, + "specularlightingspot" => { + let surface_scale = self["surface_scale"].as_f32().unwrap(); + let specular_constant = self["specular_constant"].as_f32().unwrap(); + let specular_exponent = self["specular_exponent"].as_f32().unwrap(); + let kernel_unit_length_x = self["kernel_unit_length_x"].as_f32().unwrap(); + let kernel_unit_length_y = self["kernel_unit_length_y"].as_f32().unwrap(); + let x = self["x"].as_f32().unwrap(); + let y = self["y"].as_f32().unwrap(); + let z = self["z"].as_f32().unwrap(); + let points_at_x = self["points_at_x"].as_f32().unwrap(); + let points_at_y = self["points_at_y"].as_f32().unwrap(); + let points_at_z = self["points_at_z"].as_f32().unwrap(); + let cone_exponent = self["cone_exponent"].as_f32().unwrap(); + let limiting_cone_angle = self["limiting_cone_angle"].as_f32().unwrap(); + Some(FilterOp::SVGFESpecularLightingSpot{ + node, surface_scale, specular_constant, + specular_exponent, kernel_unit_length_x, + kernel_unit_length_y, x, y, z, points_at_x, + points_at_y, points_at_z, limiting_cone_angle, + cone_exponent}) + }, + "tile" => Some(FilterOp::SVGFETile{node}), + "turbulencewithfractalnoisewithnostitching" => { + let base_frequency_x = self["base_frequency_x"].as_f32().unwrap(); + let base_frequency_y = self["base_frequency_y"].as_f32().unwrap(); + let num_octaves = self["num_octaves"].as_i64().unwrap() as u32; + let seed = self["seed"].as_i64().unwrap() as u32; + Some(FilterOp::SVGFETurbulenceWithFractalNoiseWithNoStitching{ + node, base_frequency_x, base_frequency_y, num_octaves, seed}) + }, + "turbulencewithfractalnoisewithstitching" => { + let base_frequency_x = self["base_frequency_x"].as_f32().unwrap(); + let base_frequency_y = self["base_frequency_y"].as_f32().unwrap(); + let num_octaves = self["num_octaves"].as_i64().unwrap() as u32; + let seed = self["seed"].as_i64().unwrap() as u32; + Some(FilterOp::SVGFETurbulenceWithFractalNoiseWithStitching{ + node, base_frequency_x, base_frequency_y, num_octaves, seed}) + }, + "turbulencewithturbulencenoisewithnostitching" => { + let base_frequency_x = self["base_frequency_x"].as_f32().unwrap(); + let base_frequency_y = self["base_frequency_y"].as_f32().unwrap(); + let num_octaves = self["num_octaves"].as_i64().unwrap() as u32; + let seed = self["seed"].as_i64().unwrap() as u32; + Some(FilterOp::SVGFETurbulenceWithTurbulenceNoiseWithNoStitching{ + node, base_frequency_x, base_frequency_y, num_octaves, seed}) + }, + "turbulencewithturbulencenoisewithstitching" => { + let base_frequency_x = self["base_frequency_x"].as_f32().unwrap(); + let base_frequency_y = self["base_frequency_y"].as_f32().unwrap(); + let num_octaves = self["num_octaves"].as_i64().unwrap() as u32; + let seed = self["seed"].as_i64().unwrap() as u32; + Some(FilterOp::SVGFETurbulenceWithTurbulenceNoiseWithStitching{ + node, base_frequency_x, base_frequency_y, num_octaves, seed}) + }, + _ => None, + } + } if let Some(s) = self.as_str() { match parse_function(s) { ("identity", _, _) => { -- cgit v1.2.3