commit b053233b8e5a4414cc4a3fa3e8974ea141dc45d9 parent a1b869cdace36c0f05c7391923a7f6da646b29f3 Author: Cristina Horotan <chorotan@mozilla.com> Date: Sun, 23 Nov 2025 00:03:26 +0200 Revert "Bug 2000393 - Add LinearGradientBrushData. r=gw" for causing conflict when backing out Bug 1996818 This reverts commit 1acc4435576ca5ed679d6277403da97b7d5bed98. Revert "Bug 2000393 - Add YuvPrimitive. r=gw" This reverts commit 86b60597ed89fdd437f97225d0c7a16216db3c41. Revert "Bug 2000393 - Add QuadHeader. r=gw" This reverts commit 142df7f40fd0b59496ecfc2902a23f867bd1c593. Revert "Bug 2000393 - Add QuadPrimitive and QuadSegment. r=gw" This reverts commit 38ba3fdd3a59f5de0a3e1f956a2a9413f5d14c89. Revert "Bug 2000393 - Add BrushSegmentGpuData. r=gw" This reverts commit 3c53e519462d2ad860baa1a4a5ae590f8875cac8. Revert "Bug 2000393 - Rename BrushImageData into BrushImageUserData. r=gw" This reverts commit 0e59f2a24e9eb175ef994ac6977ff74b7364c4ba. Revert "Bug 2000393 - Add GpuBufferDataF and implement it for image brush data. r=gw" This reverts commit 918aabf89b3b1acabddeb49e0167c1ce9173aa7a. Diffstat:
20 files changed, 223 insertions(+), 388 deletions(-)
diff --git a/gfx/wr/webrender/res/brush.glsl b/gfx/wr/webrender/res/brush.glsl @@ -109,7 +109,6 @@ void brush_shader_main_vs( segment_rect = ph.local_rect; segment_data = vec4(0.0); } else { - // See BrushSegmentGpuData int segment_address = ph.specific_prim_address + VECS_PER_SPECIFIC_BRUSH + instance.segment_index * VECS_PER_SEGMENT; diff --git a/gfx/wr/webrender/res/brush_image.glsl b/gfx/wr/webrender/res/brush_image.glsl @@ -31,15 +31,15 @@ flat varying mediump vec2 v_perspective; #define BLEND_MODE_ALPHA 0 #define BLEND_MODE_PREMUL_ALPHA 1 -struct ImageBrushPrimitiveData { +struct ImageBrushData { vec4 color; vec4 background_color; vec2 stretch_size; }; -ImageBrushPrimitiveData fetch_image_data(int address) { +ImageBrushData fetch_image_data(int address) { vec4[3] raw_data = fetch_from_gpu_buffer_3f(address); - ImageBrushPrimitiveData data = ImageBrushPrimitiveData( + ImageBrushData data = ImageBrushData( raw_data[0], raw_data[1], raw_data[2].xy @@ -63,7 +63,7 @@ void brush_vs( int brush_flags, vec4 segment_data ) { - ImageBrushPrimitiveData image_data = fetch_image_data(prim_address); + ImageBrushData image_data = fetch_image_data(prim_address); // If this is in WR_FEATURE_TEXTURE_RECT mode, the rect and size use // non-normalized texture coordinates. diff --git a/gfx/wr/webrender/res/brush_linear_gradient.glsl b/gfx/wr/webrender/res/brush_linear_gradient.glsl @@ -13,15 +13,15 @@ flat varying mediump vec2 v_scale_dir; #ifdef WR_VERTEX_SHADER -struct LinearGradientBrushData { +struct Gradient { vec4 start_end_point; int extend_mode; vec2 stretch_size; }; -LinearGradientBrushData fetch_gradient(int address) { +Gradient fetch_gradient(int address) { vec4 data[2] = fetch_from_gpu_buffer_2f(address); - return LinearGradientBrushData( + return Gradient( data[0], int(data[1].x), data[1].yz @@ -40,7 +40,7 @@ void brush_vs( int brush_flags, vec4 texel_rect ) { - LinearGradientBrushData gradient = fetch_gradient(prim_address); + Gradient gradient = fetch_gradient(prim_address); write_gradient_vertex( vi, diff --git a/gfx/wr/webrender/src/batch.rs b/gfx/wr/webrender/src/batch.rs @@ -15,7 +15,7 @@ use crate::gpu_types::{BrushFlags, BrushInstance, ImageSource, PrimitiveHeaders, use crate::gpu_types::SplitCompositeInstance; use crate::gpu_types::{PrimitiveInstanceData, RasterizationSpace, GlyphInstance}; use crate::gpu_types::{PrimitiveHeader, PrimitiveHeaderIndex, TransformPaletteId, TransformPalette}; -use crate::gpu_types::{ImageBrushUserData, get_shader_opacity, BoxShadowData, MaskInstance}; +use crate::gpu_types::{ImageBrushData, get_shader_opacity, BoxShadowData, MaskInstance}; use crate::gpu_types::{ClipMaskInstanceCommon, ClipMaskInstanceRect, ClipMaskInstanceBoxShadow}; use crate::internal_types::{FastHashMap, Filter, FrameAllocator, FrameMemory, FrameVec, Swizzle, TextureSource}; use crate::picture::{Picture3DContext, PictureCompositeMode, calculate_screen_uv}; @@ -1112,7 +1112,7 @@ impl BatchBuilder { textures, ); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1166,7 +1166,7 @@ impl BatchBuilder { local_rect: shadow_rect, specific_prim_address: shadow_prim_address.as_int(), z: z_id, - user_data: ImageBrushUserData { + user_data: ImageBrushData { color_mode: ShaderColorMode::Alpha, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1193,7 +1193,7 @@ impl BatchBuilder { // Update z_id for the content z_id = z_generator.next(); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1329,7 +1329,7 @@ impl BatchBuilder { textures, ); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: match key.blend_mode { BlendMode::MultiplyDualSource => ShaderColorMode::MultiplyDualSource, _ => ShaderColorMode::Image, @@ -1479,7 +1479,7 @@ impl BatchBuilder { let batch_params = BrushBatchParameters::shared( BrushBatchKind::Image(ImageBufferKind::Texture2D), textures, - ImageBrushUserData { + ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1532,7 +1532,7 @@ impl BatchBuilder { textures, ); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1551,7 +1551,7 @@ impl BatchBuilder { textures, ); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, @@ -1660,7 +1660,7 @@ impl BatchBuilder { let textures = TextureSet::prim_textured(texture_source); - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Local, @@ -1820,7 +1820,7 @@ impl BatchBuilder { let batch_params = BrushBatchParameters::instanced( BrushBatchKind::Image(image_buffer_kind), - ImageBrushUserData { + ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Local, @@ -2091,7 +2091,7 @@ impl BatchBuilder { ( BrushBatchKind::Image(texture.image_buffer_kind()), textures, - ImageBrushUserData { + ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Local, @@ -2282,7 +2282,7 @@ impl BatchBuilder { let image_data = &ctx.data_stores.image[data_handle].kind; let image_instance = &ctx.prim_store.images[image_instance_index]; - let prim_user_data = ImageBrushUserData { + let prim_user_data = ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: image_data.alpha_type, raster_space: RasterizationSpace::Local, @@ -2544,7 +2544,7 @@ impl BatchBuilder { let prim_header = PrimitiveHeader { specific_prim_address: ctx.globals.default_image_data.as_int(), - user_data: ImageBrushUserData { + user_data: ImageBrushData { color_mode: ShaderColorMode::Image, alpha_type: AlphaType::PremultipliedAlpha, raster_space: RasterizationSpace::Screen, diff --git a/gfx/wr/webrender/src/box_shadow.rs b/gfx/wr/webrender/src/box_shadow.rs @@ -101,8 +101,8 @@ impl PatternBuilder for BoxShadowTemplate { let pattern_prim_address_f = quad::write_prim_blocks( &mut state.frame_gpu_data.f32, - pattern_rect.to_untyped(), - pattern_rect.to_untyped(), + pattern_rect, + pattern_rect, color_pattern.base_color, color_pattern.texture_input.task_id, &[], diff --git a/gfx/wr/webrender/src/frame_builder.rs b/gfx/wr/webrender/src/frame_builder.rs @@ -13,7 +13,7 @@ use crate::spatial_node::SpatialNodeType; use crate::spatial_tree::{SpatialTree, SpatialNodeIndex}; use crate::composite::{CompositorKind, CompositeState, CompositeStatePreallocator}; use crate::debug_item::DebugItem; -use crate::gpu_types::{ImageBrushPrimitiveData, PrimitiveHeaders, TransformPalette, ZBufferIdGenerator}; +use crate::gpu_types::{PrimitiveHeaders, TransformPalette, ZBufferIdGenerator}; use crate::gpu_types::{QuadSegment, TransformData}; use crate::internal_types::{FastHashMap, PlaneSplitter, FrameStamp}; use crate::picture::{DirtyRegion, SliceId, TileCacheInstance}; @@ -24,7 +24,7 @@ use crate::prim_store::{PictureIndex, PrimitiveScratchBuffer}; use crate::prim_store::{DeferredResolve, PrimitiveInstance}; use crate::profiler::{self, TransactionProfile}; use crate::render_backend::{DataStores, ScratchBuffer}; -use crate::renderer::{GpuBufferAddress, GpuBufferBuilder, GpuBufferBuilderF, GpuBufferBuilderI, GpuBufferF, GpuBufferI, GpuBufferDataF}; +use crate::renderer::{GpuBufferAddress, GpuBufferBuilder, GpuBufferBuilderF, GpuBufferBuilderI, GpuBufferF, GpuBufferI}; use crate::render_target::{PictureCacheTarget, PictureCacheTargetKind}; use crate::render_target::{RenderTargetContext, RenderTargetKind, RenderTarget}; use crate::render_task_graph::{Pass, RenderTaskGraph, RenderTaskId, SubPassSurface}; @@ -100,13 +100,15 @@ impl FrameGlobalResources { &mut self, gpu_buffers: &mut GpuBufferBuilder, ) { - let mut writer = gpu_buffers.f32.write_blocks(ImageBrushPrimitiveData::NUM_BLOCKS); - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - // -ve means use prim rect for stretch size - stretch_size: LayoutSize::new(-1.0, 0.0), - }); + let mut writer = gpu_buffers.f32.write_blocks(3); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + -1.0, // -ve means use prim rect for stretch size + 0.0, + 0.0, + 0.0, + ]); self.default_image_data = writer.finish(); let mut writer = gpu_buffers.f32.write_blocks(1); diff --git a/gfx/wr/webrender/src/gpu_types.rs b/gfx/wr/webrender/src/gpu_types.rs @@ -2,21 +2,19 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use api::{AlphaType, ExtendMode, PremultipliedColorF, YuvFormat, YuvRangedColorSpace}; +use api::{AlphaType, PremultipliedColorF, YuvFormat, YuvRangedColorSpace}; use api::units::*; use euclid::HomogeneousVector; use crate::composite::{CompositeFeatures, CompositorClip}; -use crate::pattern::PatternShaderInput; -use crate::quad::LayoutOrDeviceRect; use crate::segment::EdgeAaSegmentMask; use crate::spatial_tree::{SpatialTree, SpatialNodeIndex}; use crate::internal_types::{FastHashMap, FrameVec, FrameMemory}; -use crate::prim_store::{ClipData, VECS_PER_SEGMENT}; +use crate::prim_store::ClipData; use crate::render_task::RenderTaskAddress; use crate::render_task_graph::RenderTaskId; -use crate::renderer::{GpuBufferAddress, GpuBufferBuilderF, GpuBufferDataF, GpuBufferDataI, GpuBufferWriterF, GpuBufferWriterI, ShaderColorMode}; +use crate::renderer::{GpuBufferAddress, GpuBufferBuilderF, GpuBufferWriterF, ShaderColorMode}; use std::i32; -use crate::util::{MatrixHelpers, ScaleOffset, TransformedRectKind}; +use crate::util::{MatrixHelpers, TransformedRectKind}; use glyph_rasterizer::SubpixelDirection; use crate::util::pack_as_float; @@ -24,7 +22,6 @@ use crate::util::pack_as_float; // Contains type that must exactly match the same structures declared in GLSL. pub const VECS_PER_TRANSFORM: usize = 8; -pub const VECS_PER_SPECIFIC_BRUSH: usize = 3; #[derive(Copy, Clone, Debug, PartialEq)] #[repr(C)] @@ -648,94 +645,13 @@ impl From<QuadInstance> for PrimitiveInstanceData { } } -/// Matches QuadHeader in ps_quad.glsl -pub struct QuadHeader { - pub transform_id: TransformPaletteId, - pub z_id: ZBufferId, - pub pattern_input: PatternShaderInput, -} - -impl GpuBufferDataI for QuadHeader { - const NUM_BLOCKS: usize = 1; - fn write(&self, writer: &mut GpuBufferWriterI) { - writer.push_one([ - self.transform_id.0 as i32, - self.z_id.0, - self.pattern_input.0, - self.pattern_input.1, - ]); - } -} - -/// Matches QuadPrimitive in ps_quad.glsl -pub struct QuadPrimitive { - pub bounds: LayoutOrDeviceRect, - pub clip: LayoutOrDeviceRect, - // TODO: This gets translated into a Rect just before upload. - // It would be better to send the gpu buffer address to the shader. - pub input_task: RenderTaskId, - pub pattern_scale_offset: ScaleOffset, - /// Base color of the pattern. - pub color: PremultipliedColorF, -} - -impl GpuBufferDataF for QuadPrimitive { - const NUM_BLOCKS: usize = 5; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one(self.bounds); - writer.push_one(self.clip); - writer.push_render_task(self.input_task); - writer.push_one(self.pattern_scale_offset); - writer.push_one(self.color); - } -} - -pub const VECS_PER_QUAD_SEGMENT: usize = 2; - -/// Matches QuadSegment in ps_quad.glsl #[derive(Debug)] #[cfg_attr(feature = "capture", derive(Serialize))] pub struct QuadSegment { - pub rect: LayoutOrDeviceRect, - // TODO: This gets translated into a Rect just before upload. - // It would be better to send the gpu buffer address to the shader. + pub rect: LayoutRect, pub task_id: RenderTaskId, } -impl GpuBufferDataF for QuadSegment { - const NUM_BLOCKS: usize = VECS_PER_QUAD_SEGMENT; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one(self.rect); - writer.push_render_task(self.task_id) - } -} - -/// Matches LinearGradientBrushData in brush_linear_gradient.glsl -pub struct LinearGradientBrushData { - pub start: LayoutPoint, - pub end: LayoutPoint, - pub extend_mode: ExtendMode, - pub stretch_size: LayoutSize, -} - -impl GpuBufferDataF for LinearGradientBrushData { - const NUM_BLOCKS: usize = 2; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one([ - self.start.x, - self.start.y, - self.end.x, - self.end.y, - ]); - writer.push_one([ - pack_as_float(self.extend_mode as u32), - self.stretch_size.width, - self.stretch_size.height, - 0.0, - ]); - } -} - #[derive(Copy, Debug, Clone, PartialEq)] #[cfg_attr(feature = "capture", derive(Serialize))] #[cfg_attr(feature = "replay", derive(Deserialize))] @@ -847,14 +763,14 @@ impl From<BrushInstance> for PrimitiveInstanceData { /// Convenience structure to encode into the image brush's user data. #[derive(Copy, Clone, Debug)] -pub struct ImageBrushUserData { +pub struct ImageBrushData { pub color_mode: ShaderColorMode, pub alpha_type: AlphaType, pub raster_space: RasterizationSpace, pub opacity: f32, } -impl ImageBrushUserData { +impl ImageBrushData { #[inline] pub fn encode(&self) -> [i32; 4] { [ @@ -1122,61 +1038,6 @@ impl ImageSource { } } -// Must correspond to ImageBrushPrimitiveData in brush_image.glsl -// Images are drawn as a white color, modulated by the total -// opacity coming from any collapsed property bindings. -#[derive(Copy, Clone, Debug)] -pub struct ImageBrushPrimitiveData { - pub color: PremultipliedColorF, - pub background_color: PremultipliedColorF, - pub stretch_size: LayoutSize, -} - -impl GpuBufferDataF for ImageBrushPrimitiveData { - const NUM_BLOCKS: usize = VECS_PER_SPECIFIC_BRUSH; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one(self.color); - writer.push_one(self.background_color); - writer.push_one([self.stretch_size.width, self.stretch_size.height, 0.0, 0.0]); - } -} - -#[cfg_attr(feature = "capture", derive(Serialize))] -#[cfg_attr(feature = "replay", derive(Deserialize))] -#[derive(Debug, Clone, MallocSizeOf)] -pub struct BrushSegmentGpuData { - pub local_rect: LayoutRect, - /// Each brush shader has its own interpretation of this field. - pub extra_data: [f32; 4], -} - -impl GpuBufferDataF for BrushSegmentGpuData { - const NUM_BLOCKS: usize = VECS_PER_SEGMENT; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one(self.local_rect); - writer.push_one(self.extra_data); - } -} - -/// Matches YuvPrimitive in yuv.glsl -pub struct YuvPrimitive { - pub channel_bit_depth: u32, - pub color_space: YuvRangedColorSpace, - pub yuv_format: YuvFormat, -} - -impl GpuBufferDataF for YuvPrimitive { - const NUM_BLOCKS: usize = 1; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one([ - pack_as_float(self.channel_bit_depth), - pack_as_float(self.color_space as u32), - pack_as_float(self.yuv_format as u32), - 0.0 - ]); - } -} - // Set the local -> world transform for a given spatial // node in the transform palette. fn register_transform( diff --git a/gfx/wr/webrender/src/picture.rs b/gfx/wr/webrender/src/picture.rs @@ -116,7 +116,7 @@ use crate::intern::ItemUid; use crate::internal_types::{FastHashMap, FastHashSet, PlaneSplitter, FilterGraphOp, FilterGraphNode, Filter, FrameId}; use crate::internal_types::{PlaneSplitterIndex, PlaneSplitAnchor, TextureSource}; use crate::frame_builder::{FrameBuildingContext, FrameBuildingState, PictureState, PictureContext}; -use crate::gpu_types::{BlurEdgeMode, BrushSegmentGpuData, ImageBrushPrimitiveData, UvRectKind, ZBufferId}; +use crate::gpu_types::{UvRectKind, ZBufferId, BlurEdgeMode}; use peek_poke::{PeekPoke, poke_into_vec, peek_from_slice, ensure_red_zone}; use plane_split::{Clipper, Polygon}; use crate::prim_store::{PrimitiveTemplateKind, PictureIndex, PrimitiveInstance, PrimitiveInstanceKind}; @@ -7273,16 +7273,18 @@ impl PicturePrimitive { ).translate(shadow.offset); // ImageBrush colors - writer.push(&ImageBrushPrimitiveData { - color: shadow.color.premultiplied(), - background_color: PremultipliedColorF::WHITE, - stretch_size: shadow_rect.size(), - }); - - writer.push(&BrushSegmentGpuData { - local_rect: shadow_rect, - extra_data: [0.0; 4], - }); + writer.push_one(shadow.color.premultiplied()); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + shadow_rect.width(), + shadow_rect.height(), + 0.0, + 0.0, + ]); + + // segment rect / extra data + writer.push_one(shadow_rect); + writer.push_one([0.0, 0.0, 0.0, 0.0]); *extra_handle = writer.finish(); } diff --git a/gfx/wr/webrender/src/prepare.rs b/gfx/wr/webrender/src/prepare.rs @@ -17,11 +17,11 @@ use crate::image_tiling::{self, Repetition}; use crate::border::{get_max_scale_for_border, build_border_instances}; use crate::clip::{ClipStore, ClipNodeRange}; use crate::pattern::Pattern; -use crate::renderer::{GpuBufferAddress, GpuBufferBuilderF, GpuBufferWriterF, GpuBufferDataF}; +use crate::renderer::{GpuBufferAddress, GpuBufferBuilderF, GpuBufferWriterF}; use crate::spatial_tree::{SpatialNodeIndex, SpatialTree}; use crate::clip::{ClipDataStore, ClipNodeFlags, ClipChainInstance, ClipItemKind}; use crate::frame_builder::{FrameBuildingContext, FrameBuildingState, PictureContext, PictureState}; -use crate::gpu_types::{BrushFlags, LinearGradientBrushData}; +use crate::gpu_types::BrushFlags; use crate::internal_types::{FastHashMap, PlaneSplitAnchor, Filter}; use crate::picture::{ClusterFlags, PictureCompositeMode, PicturePrimitive, SliceId}; use crate::picture::{PrimitiveList, PrimitiveCluster, SurfaceIndex, TileCacheInstance, SubpixelMode, Picture3DContext}; @@ -35,7 +35,7 @@ use crate::render_task_cache::RenderTaskCacheKeyKind; use crate::render_task_cache::{RenderTaskCacheKey, to_cache_size, RenderTaskParent}; use crate::render_task::{EmptyTask, MaskSubPass, RenderTask, RenderTaskKind, SubPass}; use crate::segment::SegmentBuilder; -use crate::util::{clamp_to_scale_factor, ScaleOffset}; +use crate::util::{clamp_to_scale_factor, pack_as_float, ScaleOffset}; use crate::visibility::{compute_conservative_visible_rect, PrimitiveVisibility, VisibilityState}; @@ -786,13 +786,20 @@ fn prepare_interned_prim_for_render( &mut scratch.gradient_tiles, &frame_context.spatial_tree, Some(&mut |_, gpu_buffer| { - let mut writer = gpu_buffer.write_blocks(LinearGradientBrushData::NUM_BLOCKS); - writer.push(&LinearGradientBrushData { - start: prim_data.start_point, - end: prim_data.end_point, - extend_mode: prim_data.extend_mode, - stretch_size: prim_data.stretch_size, - }); + let mut writer = gpu_buffer.write_blocks(2); + writer.push_one([ + prim_data.start_point.x, + prim_data.start_point.y, + prim_data.end_point.x, + prim_data.end_point.y, + ]); + writer.push_one([ + pack_as_float(prim_data.extend_mode as u32), + prim_data.stretch_size.width, + prim_data.stretch_size.height, + 0.0, + ]); + writer.finish() }), ); @@ -999,7 +1006,7 @@ fn prepare_interned_prim_for_render( } let pic_surface_index = pic.raster_config.as_ref().unwrap().surface_index; - let prim_local_rect: LayoutRect = frame_state + let prim_local_rect = frame_state .surfaces[pic_surface_index.0] .clipped_local_rect .cast_unit(); @@ -1008,8 +1015,8 @@ fn prepare_interned_prim_for_render( let prim_address_f = quad::write_prim_blocks( &mut frame_state.frame_gpu_data.f32, - prim_local_rect.to_untyped(), - prim_instance.vis.clip_chain.local_clip_rect.to_untyped(), + prim_local_rect, + prim_instance.vis.clip_chain.local_clip_rect, pattern.base_color, pattern.texture_input.task_id, &[], @@ -1221,7 +1228,8 @@ fn write_segment<F>( f(&mut writer); for segment in segments { - segment.write_gpu_blocks(&mut writer); + writer.push_one(segment.local_rect); + writer.push_one([0.0; 4]); } segment_instance.gpu_data = writer.finish(); diff --git a/gfx/wr/webrender/src/prim_store/borders.rs b/gfx/wr/webrender/src/prim_store/borders.rs @@ -6,7 +6,6 @@ use api::{NormalBorder, PremultipliedColorF, Shadow, RasterSpace}; use api::units::*; use crate::border::create_border_segments; use crate::border::NormalBorderAu; -use crate::gpu_types::ImageBrushPrimitiveData; use crate::renderer::GpuBufferWriterF; use crate::scene_building::{CreateShadow, IsVisible}; use crate::frame_builder::FrameBuildingState; @@ -80,11 +79,14 @@ impl NormalBorderData { // Border primitives currently used for // image borders, and run through the // normal brush_image shader. - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - stretch_size: prim_size, - }); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + prim_size.width, + prim_size.height, + 0.0, + 0.0, + ]); } fn write_segment_gpu_blocks( @@ -92,9 +94,11 @@ impl NormalBorderData { writer: &mut GpuBufferWriterF, ) { for segment in &self.brush_segments { - segment.write_gpu_blocks(writer); + // has to match VECS_PER_SEGMENT + writer.push_one(segment.local_rect); + writer.push_one(segment.extra_data); } - } + } } pub type NormalBorderTemplate = PrimTemplate<NormalBorderData>; @@ -275,11 +279,14 @@ impl ImageBorderData { // Border primitives currently used for // image borders, and run through the // normal brush_image shader. - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - stretch_size: *prim_size, - }); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + prim_size.width, + prim_size.height, + 0.0, + 0.0, + ]); } fn write_segment_gpu_blocks( @@ -287,7 +294,9 @@ impl ImageBorderData { writer: &mut GpuBufferWriterF, ) { for segment in &self.brush_segments { - segment.write_gpu_blocks(writer); + // has to match VECS_PER_SEGMENT + writer.push_one(segment.local_rect); + writer.push_one(segment.extra_data); } } } diff --git a/gfx/wr/webrender/src/prim_store/gradient/conic.rs b/gfx/wr/webrender/src/prim_store/gradient/conic.rs @@ -11,7 +11,6 @@ use euclid::vec2; use api::{ColorF, ExtendMode, GradientStop, PremultipliedColorF}; use api::units::*; -use crate::gpu_types::ImageBrushPrimitiveData; use crate::pattern::{Pattern, PatternBuilder, PatternBuilderContext, PatternBuilderState, PatternKind, PatternShaderInput, PatternTextureInput}; use crate::prim_store::gradient::{gpu_gradient_stops_blocks, write_gpu_gradient_stops_tree, GradientKind}; use crate::scene_building::IsVisible; @@ -264,14 +263,19 @@ impl ConicGradientTemplate { ) { let mut writer = frame_state.frame_gpu_data.f32.write_blocks(3 + self.brush_segments.len() * VECS_PER_SEGMENT); // write_prim_gpu_blocks - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - stretch_size: self.stretch_size, - }); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + self.stretch_size.width, + self.stretch_size.height, + 0.0, + 0.0, + ]); // write_segment_gpu_blocks for segment in &self.brush_segments { - segment.write_gpu_blocks(&mut writer); + // has to match VECS_PER_SEGMENT + writer.push_one(segment.local_rect); + writer.push_one(segment.extra_data); } self.common.gpu_buffer_address = writer.finish(); diff --git a/gfx/wr/webrender/src/prim_store/gradient/linear.rs b/gfx/wr/webrender/src/prim_store/gradient/linear.rs @@ -12,7 +12,6 @@ use euclid::approxeq::ApproxEq; use euclid::{point2, vec2, size2}; use api::{ExtendMode, GradientStop, LineOrientation, PremultipliedColorF, ColorF, ColorU}; use api::units::*; -use crate::gpu_types::{ImageBrushPrimitiveData, LinearGradientBrushData}; use crate::pattern::{Pattern, PatternBuilder, PatternBuilderContext, PatternBuilderState, PatternKind, PatternShaderInput, PatternTextureInput}; use crate::prim_store::gradient::{gpu_gradient_stops_blocks, write_gpu_gradient_stops_tree, write_gpu_gradient_stops_linear, GradientKind}; use crate::scene_building::IsVisible; @@ -29,6 +28,7 @@ use crate::render_task_graph::RenderTaskId; use crate::render_task_cache::{RenderTaskCacheKeyKind, RenderTaskCacheKey, RenderTaskParent}; use crate::renderer::{GpuBufferAddress, GpuBufferBuilder}; use crate::segment::EdgeAaSegmentMask; +use crate::util::pack_as_float; use super::{stops_and_min_alpha, GradientStopKey, GradientGpuBlockBuilder, apply_gradient_local_clip}; use std::ops::{Deref, DerefMut}; use std::mem::swap; @@ -84,8 +84,8 @@ impl InternDebug for LinearGradientKey {} pub struct LinearGradientTemplate { pub common: PrimTemplateCommonData, pub extend_mode: ExtendMode, - pub start_point: LayoutPoint, - pub end_point: LayoutPoint, + pub start_point: DevicePoint, + pub end_point: DevicePoint, pub task_size: DeviceIntSize, pub scale: DeviceVector2D, pub stretch_size: LayoutSize, @@ -397,8 +397,8 @@ impl From<LinearGradientKey> for LinearGradientTemplate { // should be drawn in. let stops_opacity = PrimitiveOpacity::from_alpha(min_alpha); - let start_point = LayoutPoint::new(item.start_point.x, item.start_point.y); - let end_point = LayoutPoint::new(item.end_point.x, item.end_point.y); + let start_point = DevicePoint::new(item.start_point.x, item.start_point.y); + let end_point = DevicePoint::new(item.end_point.x, item.end_point.y); let tile_spacing: LayoutSize = item.tile_spacing.into(); let stretch_size: LayoutSize = item.stretch_size.into(); let mut task_size: DeviceSize = stretch_size.cast_unit(); @@ -498,24 +498,36 @@ impl LinearGradientTemplate { // Write_prim_gpu_blocks if self.cached { - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - stretch_size: self.stretch_size, - }); + // We are using the image brush. + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + self.stretch_size.width, + self.stretch_size.height, + 0.0, + 0.0, + ]); } else { // We are using the gradient brush. - writer.push(&LinearGradientBrushData { - start: self.start_point, - end: self.end_point, - extend_mode: self.extend_mode, - stretch_size: self.stretch_size, - }); + writer.push_one([ + self.start_point.x, + self.start_point.y, + self.end_point.x, + self.end_point.y, + ]); + writer.push_one([ + pack_as_float(self.extend_mode as u32), + self.stretch_size.width, + self.stretch_size.height, + 0.0, + ]); } // write_segment_gpu_blocks for segment in &self.brush_segments { - segment.write_gpu_blocks(&mut writer); + // has to match VECS_PER_SEGMENT + writer.push_one(segment.local_rect); + writer.push_one(segment.extra_data); } self.common.gpu_buffer_address = writer.finish(); @@ -591,11 +603,8 @@ impl LinearGradientTemplate { rg_builder.add().init(RenderTask::new_dynamic( self.task_size, RenderTaskKind::LinearGradient(LinearGradientTask { - // Cached brush gradients are rasteried with 1 layout - // pixel = 1 device pixel (regardless of potential - // scaling factors). - start: self.start_point.cast_unit(), - end: self.end_point.cast_unit(), + start: self.start_point, + end: self.end_point, scale: self.scale, extend_mode: self.extend_mode, stops: stops.unwrap(), @@ -777,8 +786,8 @@ pub struct LinearGradientCacheKey { } pub fn linear_gradient_pattern( - start: LayoutPoint, - end: LayoutPoint, + start: DevicePoint, + end: DevicePoint, extend_mode: ExtendMode, stops: &[GradientStop], is_software: bool, diff --git a/gfx/wr/webrender/src/prim_store/gradient/radial.rs b/gfx/wr/webrender/src/prim_store/gradient/radial.rs @@ -11,7 +11,6 @@ use euclid::{vec2, size2}; use api::{ColorF, ColorU, ExtendMode, GradientStop, PremultipliedColorF}; use api::units::*; -use crate::gpu_types::ImageBrushPrimitiveData; use crate::pattern::{Pattern, PatternBuilder, PatternBuilderContext, PatternBuilderState, PatternKind, PatternShaderInput, PatternTextureInput}; use crate::prim_store::gradient::GradientKind; use crate::scene_building::IsVisible; @@ -232,15 +231,19 @@ impl RadialGradientTemplate { let mut writer = frame_state.frame_gpu_data.f32.write_blocks(3 + self.brush_segments.len() * VECS_PER_SEGMENT); // write_prim_gpu_blocks - writer.push(&ImageBrushPrimitiveData { - color: PremultipliedColorF::WHITE, - background_color: PremultipliedColorF::WHITE, - stretch_size: self.stretch_size, - }); - + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + self.stretch_size.width, + self.stretch_size.height, + 0.0, + 0.0, + ]); // write_segment_gpu_blocks for segment in &self.brush_segments { - segment.write_gpu_blocks(&mut writer); + // has to match VECS_PER_SEGMENT + writer.push_one(segment.local_rect); + writer.push_one(segment.extra_data); } self.common.gpu_buffer_address = writer.finish(); diff --git a/gfx/wr/webrender/src/prim_store/image.rs b/gfx/wr/webrender/src/prim_store/image.rs @@ -10,7 +10,6 @@ use api::{ use api::units::*; use euclid::point2; use crate::composite::CompositorSurfaceKind; -use crate::gpu_types::{ImageBrushPrimitiveData, YuvPrimitive}; use crate::renderer::{GpuBufferBuilderF, GpuBufferWriterF}; use crate::scene_building::{CreateShadow, IsVisible}; use crate::frame_builder::{FrameBuildingContext, FrameBuildingState}; @@ -29,6 +28,7 @@ use crate::render_task_cache::{ RenderTaskCacheKey, RenderTaskCacheKeyKind, RenderTaskParent }; use crate::resource_cache::{ImageRequest, ImageProperties, ResourceCache}; +use crate::util::pack_as_float; use crate::visibility::{PrimitiveVisibility, compute_conservative_visible_rect}; use crate::spatial_tree::SpatialNodeIndex; use crate::image_tiling; @@ -395,14 +395,18 @@ impl ImageData { } pub fn write_prim_gpu_blocks(&self, adjustment: &AdjustedImageSource, writer: &mut GpuBufferWriterF) { - let stretch_size = adjustment.map_stretch_size(self.stretch_size) - + self.tile_spacing; - - writer.push(&ImageBrushPrimitiveData { - color: self.color.premultiplied(), - background_color: PremultipliedColorF::WHITE, - stretch_size, - }); + let stretch_size = adjustment.map_stretch_size(self.stretch_size); + // Images are drawn as a white color, modulated by the total + // opacity coming from any collapsed property bindings. + // Size has to match `VECS_PER_SPECIFIC_BRUSH` from `brush_image.glsl` exactly. + writer.push_one(self.color.premultiplied()); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + stretch_size.width + self.tile_spacing.width, + stretch_size.height + self.tile_spacing.height, + 0.0, + 0.0, + ]); } } @@ -710,11 +714,13 @@ impl YuvImageData { } pub fn write_prim_gpu_blocks(&self, writer: &mut GpuBufferWriterF) { - writer.push(&YuvPrimitive { - channel_bit_depth: self.color_depth.bit_depth(), - color_space: self.color_space.with_range(self.color_range), - yuv_format: self.format, - }); + let ranged_color_space = self.color_space.with_range(self.color_range); + writer.push_one([ + pack_as_float(self.color_depth.bit_depth()), + pack_as_float(ranged_color_space as u32), + pack_as_float(self.format as u32), + 0.0 + ]); } } diff --git a/gfx/wr/webrender/src/prim_store/line_dec.rs b/gfx/wr/webrender/src/prim_store/line_dec.rs @@ -7,7 +7,6 @@ use api::{ LineOrientation, LineStyle, PremultipliedColorF, Shadow, }; use api::units::*; -use crate::gpu_types::ImageBrushPrimitiveData; use crate::renderer::GpuBufferWriterF; use crate::scene_building::{CreateShadow, IsVisible}; use crate::frame_builder::FrameBuildingState; @@ -90,14 +89,14 @@ impl LineDecorationData { ) { match self.cache_key.as_ref() { Some(cache_key) => { - writer.push(&ImageBrushPrimitiveData { - color: self.color.premultiplied(), - background_color: PremultipliedColorF::WHITE, - stretch_size: LayoutSize::new( - cache_key.size.width.to_f32_px(), - cache_key.size.height.to_f32_px(), - ), - }); + writer.push_one(self.color.premultiplied()); + writer.push_one(PremultipliedColorF::WHITE); + writer.push_one([ + cache_key.size.width.to_f32_px(), + cache_key.size.height.to_f32_px(), + 0.0, + 0.0, + ]); } None => { writer.push_one(self.color.premultiplied()); diff --git a/gfx/wr/webrender/src/prim_store/mod.rs b/gfx/wr/webrender/src/prim_store/mod.rs @@ -21,7 +21,7 @@ use crate::debug_colors; use crate::scene_building::{CreateShadow, IsVisible}; use crate::frame_builder::FrameBuildingState; use glyph_rasterizer::GlyphKey; -use crate::gpu_types::{BrushFlags, BrushSegmentGpuData, QuadSegment}; +use crate::gpu_types::{BrushFlags, QuadSegment}; use crate::intern; use crate::picture::PicturePrimitive; use crate::render_task_graph::RenderTaskId; @@ -767,17 +767,6 @@ impl BrushSegment { brush_flags, } } - - pub fn gpu_data(&self) -> BrushSegmentGpuData { - BrushSegmentGpuData { - local_rect: self.local_rect, - extra_data: self.extra_data, - } - } - - pub fn write_gpu_blocks(&self, writer: &mut GpuBufferWriterF) { - writer.push(&self.gpu_data()); - } } #[derive(Debug, Clone)] diff --git a/gfx/wr/webrender/src/quad.rs b/gfx/wr/webrender/src/quad.rs @@ -9,14 +9,14 @@ use crate::batch::{BatchKey, BatchKind, BatchTextures}; use crate::clip::{ClipChainInstance, ClipIntern, ClipItemKind, ClipNodeRange, ClipSpaceConversion, ClipStore}; use crate::command_buffer::{CommandBufferIndex, PrimitiveCommand, QuadFlags}; use crate::frame_builder::{FrameBuildingContext, FrameBuildingState, PictureContext, PictureState}; -use crate::gpu_types::{PrimitiveInstanceData, QuadHeader, QuadInstance, QuadPrimitive, QuadSegment, TransformPaletteId, ZBufferId}; +use crate::gpu_types::{PrimitiveInstanceData, QuadInstance, QuadSegment, TransformPaletteId, ZBufferId}; use crate::intern::DataStore; use crate::internal_types::TextureSource; use crate::pattern::{Pattern, PatternBuilder, PatternBuilderContext, PatternBuilderState, PatternKind, PatternShaderInput}; use crate::prim_store::{PrimitiveInstanceIndex, PrimitiveScratchBuffer}; use crate::render_task::{MaskSubPass, RenderTask, RenderTaskAddress, RenderTaskKind, SubPass}; use crate::render_task_graph::{RenderTaskGraph, RenderTaskGraphBuilder, RenderTaskId}; -use crate::renderer::{BlendMode, GpuBufferAddress, GpuBufferBuilder, GpuBufferBuilderF, GpuBufferDataI}; +use crate::renderer::{BlendMode, GpuBufferAddress, GpuBufferBuilder, GpuBufferBuilderF}; use crate::segment::EdgeAaSegmentMask; use crate::space::SpaceMapper; use crate::spatial_tree::{CoordinateSpaceMapping, SpatialNodeIndex, SpatialTree}; @@ -24,10 +24,6 @@ use crate::surface::SurfaceBuilder; use crate::util::{extract_inner_rect_k, MaxRect, ScaleOffset}; use crate::visibility::compute_conservative_visible_rect; -/// This type reflects the unfortunate situation with quad coordinates where we -/// sometimes use layout and sometimes device coordinates. -pub type LayoutOrDeviceRect = api::euclid::default::Box2D<f32>; - const MIN_AA_SEGMENTS_SIZE: f32 = 4.0; const MIN_QUAD_SPLIT_SIZE: f32 = 256.0; const MAX_TILES_PER_QUAD: usize = 4; @@ -339,8 +335,8 @@ fn prepare_quad_impl( let main_prim_address = write_prim_blocks( &mut frame_state.frame_gpu_data.f32, - local_rect.to_untyped(), - clip_chain.local_clip_rect.to_untyped(), + *local_rect, + clip_chain.local_clip_rect, pattern.base_color, pattern.texture_input.task_id, &[], @@ -399,8 +395,8 @@ fn prepare_quad_impl( let main_prim_address = write_prim_blocks( &mut frame_state.frame_gpu_data.f32, - local_rect.to_untyped(), - clip_chain.local_clip_rect.to_untyped(), + *local_rect, + clip_chain.local_clip_rect, pattern.base_color, pattern.texture_input.task_id, &[], @@ -429,7 +425,7 @@ fn prepare_quad_impl( &mut frame_state.surface_builder, ); - let rect = clipped_surface_rect.to_f32().to_untyped(); + let rect = clipped_surface_rect.to_f32().cast_unit(); add_composite_prim( pattern_builder.get_base_color(&ctx), prim_instance_index, @@ -656,8 +652,8 @@ fn prepare_quad_impl( let main_prim_address = write_prim_blocks( &mut state.frame_gpu_data.f32, - local_rect.to_untyped(), - clip_chain.local_clip_rect.to_untyped(), + *local_rect, + clip_chain.local_clip_rect, pattern.base_color, pattern.texture_input.task_id, &[], @@ -708,8 +704,8 @@ fn prepare_quad_impl( &pattern, local_to_device.inverse(), prim_instance_index, - device_prim_rect.to_untyped(), - clip_coverage_rect.to_untyped(), + device_prim_rect.cast_unit(), + clip_coverage_rect.cast_unit(), pattern.is_opaque, frame_state, targets, @@ -721,7 +717,7 @@ fn prepare_quad_impl( add_composite_prim( pattern_builder.get_base_color(&ctx), prim_instance_index, - clip_coverage_rect.to_untyped(), + clip_coverage_rect.cast_unit(), frame_state, targets, &scratch.quad_indirect_segments, @@ -833,8 +829,8 @@ fn prepare_quad_impl( let main_prim_address = write_prim_blocks( &mut state.frame_gpu_data.f32, - local_rect.to_untyped(), - clip_chain.local_clip_rect.to_untyped(), + *local_rect, + clip_chain.local_clip_rect, pattern.base_color, pattern.texture_input.task_id, &[], @@ -1035,8 +1031,8 @@ fn add_pattern_prim( pattern: &Pattern, pattern_transform: ScaleOffset, prim_instance_index: PrimitiveInstanceIndex, - rect: LayoutOrDeviceRect, - clip_rect: LayoutOrDeviceRect, + rect: LayoutRect, + clip_rect: LayoutRect, is_opaque: bool, frame_state: &mut FrameBuildingState, targets: &[CommandBufferIndex], @@ -1080,7 +1076,7 @@ fn add_pattern_prim( fn add_composite_prim( base_color: ColorF, prim_instance_index: PrimitiveInstanceIndex, - rect: LayoutOrDeviceRect, + rect: LayoutRect, frame_state: &mut FrameBuildingState, targets: &[CommandBufferIndex], segments: &[QuadSegment], @@ -1125,25 +1121,24 @@ fn add_composite_prim( pub fn write_prim_blocks( builder: &mut GpuBufferBuilderF, - prim_rect: LayoutOrDeviceRect, - clip_rect: LayoutOrDeviceRect, + prim_rect: LayoutRect, + clip_rect: LayoutRect, pattern_base_color: ColorF, pattern_texture_input: RenderTaskId, segments: &[QuadSegment], - pattern_scale_offset: ScaleOffset, + scale_offset: ScaleOffset, ) -> GpuBufferAddress { let mut writer = builder.write_blocks(5 + segments.len() * 2); - writer.push(&QuadPrimitive { - bounds: prim_rect, - clip: clip_rect, - input_task: pattern_texture_input, - pattern_scale_offset, - color: pattern_base_color.premultiplied(), - }); + writer.push_one(prim_rect); + writer.push_one(clip_rect); + writer.push_render_task(pattern_texture_input); + writer.push_one(scale_offset); + writer.push_one(pattern_base_color.premultiplied()); for segment in segments { - writer.push(segment); + writer.push_one(segment.rect); + writer.push_render_task(segment.task_id) } writer.finish() @@ -1177,12 +1172,13 @@ pub fn add_to_batch<F>( } // See QuadHeader in ps_quad.glsl - let mut writer = gpu_buffer_builder.i32.write_blocks(QuadHeader::NUM_BLOCKS); - writer.push(&QuadHeader { - transform_id, - z_id, - pattern_input, - }); + let mut writer = gpu_buffer_builder.i32.write_blocks(1); + writer.push_one([ + transform_id.0 as i32, + z_id.0, + pattern_input.0, + pattern_input.1, + ]); let prim_address_i = writer.finish(); let texture = match src_task_id { diff --git a/gfx/wr/webrender/src/render_target.rs b/gfx/wr/webrender/src/render_target.rs @@ -1053,12 +1053,12 @@ fn build_mask_tasks( for tile in clip_store.visible_mask_tiles(&clip_instance) { let clip_prim_address = quad::write_prim_blocks( &mut gpu_buffer_builder.f32, - rect.to_untyped(), - rect.to_untyped(), + rect, + rect, pattern.base_color, pattern.texture_input.task_id, &[QuadSegment { - rect: tile.tile_rect.to_untyped(), + rect: tile.tile_rect, task_id: tile.task_id, }], ScaleOffset::identity(), @@ -1123,8 +1123,8 @@ fn build_mask_tasks( let main_prim_address = quad::write_prim_blocks( &mut gpu_buffer_builder.f32, - task_world_rect.to_untyped(), - task_world_rect.to_untyped(), + task_world_rect.cast_unit(), + task_world_rect.cast_unit(), pattern.base_color, pattern.texture_input.task_id, &[], diff --git a/gfx/wr/webrender/src/renderer/gpu_buffer.rs b/gfx/wr/webrender/src/renderer/gpu_buffer.rs @@ -30,7 +30,7 @@ pub type GpuBufferI = GpuBuffer<GpuBufferBlockI>; pub type GpuBufferBuilderI = GpuBufferBuilderImpl<GpuBufferBlockI>; pub type GpuBufferWriterF<'l> = GpuBufferWriter<'l, GpuBufferBlockF>; -pub type GpuBufferWriterI<'l> = GpuBufferWriter<'l, GpuBufferBlockI>; +//pub type GpuBufferWriterI<'l> = GpuBufferWriter<'l, GpuBufferBlockI>; unsafe impl Texel for GpuBufferBlockF { fn image_format() -> ImageFormat { ImageFormat::RGBAF32 } @@ -129,19 +129,6 @@ impl Into<GpuBufferBlockF> for LayoutRect { } } -impl Into<GpuBufferBlockF> for crate::quad::LayoutOrDeviceRect { - fn into(self) -> GpuBufferBlockF { - GpuBufferBlockF { - data: [ - self.min.x, - self.min.y, - self.max.x, - self.max.y, - ], - } - } -} - impl Into<GpuBufferBlockF> for ScaleOffset { fn into(self) -> GpuBufferBlockF { GpuBufferBlockF { @@ -236,30 +223,6 @@ impl Into<GpuBufferBlockI> for [i32; 4] { } } -pub trait GpuBufferDataF { - const NUM_BLOCKS: usize; - fn write(&self, writer: &mut GpuBufferWriterF); -} - -pub trait GpuBufferDataI { - const NUM_BLOCKS: usize; - fn write(&self, writer: &mut GpuBufferWriterI); -} - -impl GpuBufferDataF for [f32; 4] { - const NUM_BLOCKS: usize = 1; - fn write(&self, writer: &mut GpuBufferWriterF) { - writer.push_one(*self); - } -} - -impl GpuBufferDataI for [i32; 4] { - const NUM_BLOCKS: usize = 1; - fn write(&self, writer: &mut GpuBufferWriterI) { - writer.push_one(*self); - } -} - /// Record a patch to the GPU buffer for a render task struct DeferredBlock { task_id: RenderTaskId, @@ -319,20 +282,6 @@ impl<'a, T> GpuBufferWriter<'a, T> where T: Texel { } } -impl<'a> GpuBufferWriterF<'a> { - pub fn push<Data: GpuBufferDataF>(&mut self, data: &Data) { - let _start_index = self.buffer.len(); - data.write(self); - debug_assert_eq!(self.buffer.len() - _start_index, Data::NUM_BLOCKS); - } -} - -impl<'a> GpuBufferWriterI<'a> { - pub fn push<Data: GpuBufferDataI>(&mut self, data: &Data) { - data.write(self); - } -} - impl<'a, T> Drop for GpuBufferWriter<'a, T> { fn drop(&mut self) { assert!(self.buffer.len() <= self.index + self.max_block_count, "Attempt to write too many GpuBuffer blocks"); diff --git a/gfx/wr/webrender/src/renderer/mod.rs b/gfx/wr/webrender/src/renderer/mod.rs @@ -130,7 +130,6 @@ pub use shade::{PendingShadersToPrecache, Shaders, SharedShaders}; pub use vertex::{desc, VertexArrayKind, MAX_VERTEX_TEXTURE_WIDTH}; pub use gpu_buffer::{GpuBuffer, GpuBufferF, GpuBufferBuilderF, GpuBufferI, GpuBufferBuilderI}; pub use gpu_buffer::{GpuBufferAddress, GpuBufferBuilder, GpuBufferWriterF, GpuBufferBlockF}; -pub use gpu_buffer::{GpuBufferDataF, GpuBufferDataI, GpuBufferWriterI}; /// The size of the array of each type of vertex data texture that /// is round-robin-ed each frame during bind_frame_data. Doing this