Backed out changeset 2a266cdaf3a6 (bug 1881182) for causing webrender…

… build bustages. CLOSED TREE

[ghsync] From https://hg.mozilla.org/mozilla-central/rev/43d95144c3c2c5239f11a2fd9b11336fe959fcbb

webrender/res/brush_linear_gradient.glsl

@@ -82,12 +82,12 @@ Fragment brush_fs() {
 
 #ifdef SWGL_DRAW_SPAN
 void swgl_drawSpanRGBA8() {
-    int address = swgl_validateGradient(sGpuBufferF, get_gpu_buffer_uv(v_gradient_address.x), int(GRADIENT_ENTRIES + 2.0));
+    int address = swgl_validateGradient(sGpuBuffer, get_gpu_buffer_uv(v_gradient_address.x), int(GRADIENT_ENTRIES + 2.0));
     if (address < 0) {
         return;
     }
 
-    swgl_commitLinearGradientRGBA8(sGpuBufferF, address, GRADIENT_ENTRIES, true, v_gradient_repeat.x != 0.0,
+    swgl_commitLinearGradientRGBA8(sGpuBuffer, address, GRADIENT_ENTRIES, true, v_gradient_repeat.x != 0.0,
                                    v_pos, v_scale_dir, v_start_offset.x);
 }
 #endif

webrender/res/cs_linear_gradient.glsl

@@ -54,12 +54,12 @@ void main(void) {
 
 #ifdef SWGL_DRAW_SPAN
 void swgl_drawSpanRGBA8() {
-    int address = swgl_validateGradient(sGpuBufferF, get_gpu_buffer_uv(v_gradient_address.x), int(GRADIENT_ENTRIES + 2.0));
+    int address = swgl_validateGradient(sGpuBuffer, get_gpu_buffer_uv(v_gradient_address.x), int(GRADIENT_ENTRIES + 2.0));
     if (address < 0) {
         return;
     }
 
-    swgl_commitLinearGradientRGBA8(sGpuBufferF, address, GRADIENT_ENTRIES, false, v_gradient_repeat.x != 0.0,
+    swgl_commitLinearGradientRGBA8(sGpuBuffer, address, GRADIENT_ENTRIES, false, v_gradient_repeat.x != 0.0,
                                    v_pos, v_scale_dir, v_start_offset.x);
 }
 #endif

webrender/res/cs_radial_gradient.glsl

@@ -58,12 +58,12 @@ void main(void) {
 
 #ifdef SWGL_DRAW_SPAN
 void swgl_drawSpanRGBA8() {
-    int address = swgl_validateGradient(sGpuBufferF, get_gpu_buffer_uv(v_gradient_address.x),
+    int address = swgl_validateGradient(sGpuBuffer, get_gpu_buffer_uv(v_gradient_address.x),
                                         int(GRADIENT_ENTRIES + 2.0));
     if (address < 0) {
         return;
     }
-    swgl_commitRadialGradientRGBA8(sGpuBufferF, address, GRADIENT_ENTRIES, v_gradient_repeat.x != 0.0,
+    swgl_commitRadialGradientRGBA8(sGpuBuffer, address, GRADIENT_ENTRIES, v_gradient_repeat.x != 0.0,
                                    v_pos, v_start_radius.x);
 }
 #endif

webrender/res/gpu_buffer.glsl

@@ -2,42 +2,41 @@
  * 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/. */
 
-uniform HIGHP_SAMPLER_FLOAT sampler2D sGpuBufferF;
-uniform HIGHP_SAMPLER_FLOAT sampler2D sGpuBufferI;
+uniform HIGHP_SAMPLER_FLOAT sampler2D sGpuBuffer;
 
 ivec2 get_gpu_buffer_uv(HIGHP_FS_ADDRESS int address) {
     return ivec2(uint(address) % WR_MAX_VERTEX_TEXTURE_WIDTH,
                  uint(address) / WR_MAX_VERTEX_TEXTURE_WIDTH);
 }
 
-vec4 fetch_from_gpu_buffer_1f(HIGHP_FS_ADDRESS int address) {
+vec4 fetch_from_gpu_buffer_1(HIGHP_FS_ADDRESS int address) {
     ivec2 uv = get_gpu_buffer_uv(address);
-    return texelFetch(sGpuBufferF, uv, 0);
+    return texelFetch(sGpuBuffer, uv, 0);
 }
 
-vec4[2] fetch_from_gpu_buffer_2f(HIGHP_FS_ADDRESS int address) {
+vec4[2] fetch_from_gpu_buffer_2(HIGHP_FS_ADDRESS int address) {
     ivec2 uv = get_gpu_buffer_uv(address);
     return vec4[2](
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(0, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(1, 0))
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(0, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(1, 0))
     );
 }
 
-vec4[3] fetch_from_gpu_buffer_3f(HIGHP_FS_ADDRESS int address) {
+vec4[3] fetch_from_gpu_buffer_3(HIGHP_FS_ADDRESS int address) {
     ivec2 uv = get_gpu_buffer_uv(address);
     return vec4[3](
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(0, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(1, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(2, 0))
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(0, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(1, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(2, 0))
     );
 }
 
-vec4[4] fetch_from_gpu_buffer_4f(HIGHP_FS_ADDRESS int address) {
+vec4[4] fetch_from_gpu_buffer_4(HIGHP_FS_ADDRESS int address) {
     ivec2 uv = get_gpu_buffer_uv(address);
     return vec4[4](
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(0, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(1, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(2, 0)),
-        TEXEL_FETCH(sGpuBufferF, uv, 0, ivec2(3, 0))
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(0, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(1, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(2, 0)),
+        TEXEL_FETCH(sGpuBuffer, uv, 0, ivec2(3, 0))
     );
 }

webrender/res/gradient.glsl

@@ -54,7 +54,7 @@ vec4 sample_gradient(float offset) {
     float entry_fract = x - entry_index;
 
     // Fetch the start and end color. There is a [start, end] color per entry.
-    vec4 texels[2] = fetch_from_gpu_buffer_2f(v_gradient_address.x + 2 * int(entry_index));
+    vec4 texels[2] = fetch_from_gpu_buffer_2(v_gradient_address.x + 2 * int(entry_index));
 
     // Finally interpolate and apply dithering
     return dither(texels[0] + texels[1] * entry_fract);

webrender/res/ps_quad.glsl

@@ -61,7 +61,7 @@ struct QuadPrimitive {
 QuadSegment fetch_segment(int base, int index) {
     QuadSegment seg;
 
-    vec4 texels[2] = fetch_from_gpu_buffer_2f(base + 3 + index * 2);
+    vec4 texels[2] = fetch_from_gpu_buffer_2(base + 3 + index * 2);
 
     seg.rect = RectWithEndpoint(texels[0].xy, texels[0].zw);
     seg.uv_rect = texels[1];
@@ -72,7 +72,7 @@ QuadSegment fetch_segment(int base, int index) {
 QuadPrimitive fetch_primitive(int index) {
     QuadPrimitive prim;
 
-    vec4 texels[3] = fetch_from_gpu_buffer_3f(index);
+    vec4 texels[3] = fetch_from_gpu_buffer_3(index);
 
     prim.bounds = RectWithEndpoint(texels[0].xy, texels[0].zw);
     prim.clip = RectWithEndpoint(texels[1].xy, texels[1].zw);

webrender/res/ps_quad_mask.glsl

@@ -45,12 +45,12 @@ Clip fetch_clip(int index) {
     clip.space = aClipData.z;
 
 #ifdef WR_FEATURE_FAST_PATH
-    vec4 texels[3] = fetch_from_gpu_buffer_3f(index);
+    vec4 texels[3] = fetch_from_gpu_buffer_3(index);
     clip.rect = RectWithEndpoint(texels[0].xy, texels[0].zw);
     clip.radii = texels[1];
     clip.mode = texels[2].x;
 #else
-    vec4 texels[4] = fetch_from_gpu_buffer_4f(index);
+    vec4 texels[4] = fetch_from_gpu_buffer_4(index);
     clip.rect = RectWithEndpoint(texels[0].xy, texels[0].zw);
     clip.radii_top = texels[1];
     clip.radii_bottom = texels[2];

webrender/src/batch.rs

@@ -27,7 +27,7 @@ use crate::render_target::RenderTargetContext;
 use crate::render_task_graph::{RenderTaskId, RenderTaskGraph};
 use crate::render_task::{RenderTaskAddress, RenderTaskKind, SubPass};
 use crate::renderer::{BlendMode, ShaderColorMode};
-use crate::renderer::{MAX_VERTEX_TEXTURE_WIDTH, GpuBufferBuilderF, GpuBufferAddress};
+use crate::renderer::{MAX_VERTEX_TEXTURE_WIDTH, GpuBufferBuilder, GpuBufferAddress};
 use crate::resource_cache::{GlyphFetchResult, ImageProperties};
 use crate::space::SpaceMapper;
 use crate::visibility::{PrimitiveVisibilityFlags, VisibilityState};
@@ -857,7 +857,7 @@ impl BatchBuilder {
         surface_spatial_node_index: SpatialNodeIndex,
         z_generator: &mut ZBufferIdGenerator,
         prim_instances: &[PrimitiveInstance],
-        _gpu_buffer_builder: &mut GpuBufferBuilderF,
+        _gpu_buffer_builder: &mut GpuBufferBuilder,
         segments: &[RenderTaskId],
     ) {
         let (prim_instance_index, extra_prim_gpu_address) = match cmd {

webrender/src/device/gl.rs

@@ -138,13 +138,9 @@ pub enum UploadMethod {
 }
 
 /// Plain old data that can be used to initialize a texture.
-pub unsafe trait Texel: Copy + Default {
-    fn image_format() -> ImageFormat;
-}
-
-unsafe impl Texel for u8 {
-    fn image_format() -> ImageFormat { ImageFormat::R8 }
-}
+pub unsafe trait Texel: Copy {}
+unsafe impl Texel for u8 {}
+unsafe impl Texel for f32 {}
 
 /// Returns the size in bytes of a depth target with the given dimensions.
 fn depth_target_size_in_bytes(dimensions: &DeviceIntSize) -> usize {

webrender/src/frame_builder.rs

@@ -25,7 +25,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::{GpuBufferF, GpuBufferBuilderF, GpuBufferI, GpuBufferBuilderI};
+use crate::renderer::{GpuBuffer, GpuBufferBuilder};
 use crate::render_target::{RenderTarget, PictureCacheTarget, TextureCacheRenderTarget, PictureCacheTargetKind};
 use crate::render_target::{RenderTargetContext, RenderTargetKind, AlphaRenderTarget, ColorRenderTarget};
 use crate::render_task_graph::{RenderTaskGraph, Pass, SubPassSurface};
@@ -171,8 +171,7 @@ pub struct FrameBuildingState<'a> {
     pub surface_builder: SurfaceBuilder,
     pub cmd_buffers: &'a mut CommandBufferList,
     pub clip_tree: &'a ClipTree,
-    pub frame_gpu_data_f: &'a mut GpuBufferBuilderF,
-    pub frame_gpu_data_i: &'a mut GpuBufferBuilderI,
+    pub frame_gpu_data: &'a mut GpuBufferBuilder,
 }
 
 impl<'a> FrameBuildingState<'a> {
@@ -277,8 +276,7 @@ impl FrameBuilder {
         tile_caches: &mut FastHashMap<SliceId, Box<TileCacheInstance>>,
         spatial_tree: &SpatialTree,
         cmd_buffers: &mut CommandBufferList,
-        frame_gpu_data_f: &mut GpuBufferBuilderF,
-        frame_gpu_data_i: &mut GpuBufferBuilderI,
+        frame_gpu_data: &mut GpuBufferBuilder,
         profile: &mut TransactionProfile,
     ) {
         profile_scope!("build_layer_screen_rects_and_cull_layers");
@@ -430,8 +428,7 @@ impl FrameBuilder {
             surface_builder: SurfaceBuilder::new(),
             cmd_buffers,
             clip_tree: &mut scene.clip_tree,
-            frame_gpu_data_f,
-            frame_gpu_data_i,
+            frame_gpu_data,
         };
 
         // Push a default dirty region which culls primitives
@@ -561,8 +558,7 @@ impl FrameBuilder {
         let mut cmd_buffers = CommandBufferList::new();
 
         // TODO(gw): Recycle backing vec buffers for gpu buffer builder between frames
-        let mut gpu_buffer_builder_f = GpuBufferBuilderF::new();
-        let mut gpu_buffer_builder_i = GpuBufferBuilderI::new();
+        let mut gpu_buffer_builder = GpuBufferBuilder::new();
 
         self.build_layer_screen_rects_and_cull_layers(
             scene,
@@ -580,8 +576,7 @@ impl FrameBuilder {
             tile_caches,
             spatial_tree,
             &mut cmd_buffers,
-            &mut gpu_buffer_builder_f,
-            &mut gpu_buffer_builder_i,
+            &mut gpu_buffer_builder,
             profile,
         );
 
@@ -637,7 +632,7 @@ impl FrameBuilder {
                     output_size,
                     &mut ctx,
                     gpu_cache,
-                    &mut gpu_buffer_builder_f,
+                    &mut gpu_buffer_builder,
                     &render_tasks,
                     &scene.clip_store,
                     &mut transform_palette,
@@ -695,8 +690,7 @@ impl FrameBuilder {
         scene.clip_store.end_frame(&mut scratch.clip_store);
         scratch.end_frame();
 
-        let gpu_buffer_f = gpu_buffer_builder_f.finalize(&render_tasks);
-        let gpu_buffer_i = gpu_buffer_builder_i.finalize(&render_tasks);
+        let gpu_buffer = gpu_buffer_builder.finalize(&render_tasks);
 
         Frame {
             device_rect: DeviceIntRect::from_origin_and_size(
@@ -713,8 +707,7 @@ impl FrameBuilder {
             prim_headers,
             debug_items: mem::replace(&mut scratch.primitive.debug_items, Vec::new()),
             composite_state,
-            gpu_buffer_f,
-            gpu_buffer_i,
+            gpu_buffer,
         }
     }
 
@@ -901,7 +894,7 @@ pub fn build_render_pass(
     screen_size: DeviceIntSize,
     ctx: &mut RenderTargetContext,
     gpu_cache: &mut GpuCache,
-    gpu_buffer_builder: &mut GpuBufferBuilderF,
+    gpu_buffer_builder: &mut GpuBufferBuilder,
     render_tasks: &RenderTaskGraph,
     clip_store: &ClipStore,
     transforms: &mut TransformPalette,
@@ -974,7 +967,7 @@ pub fn build_render_pass(
                 let task_id = sub_pass.task_ids[0];
                 let task = &render_tasks[task_id];
                 let target_rect = task.get_target_rect();
-                let mut gpu_buffer_builder = GpuBufferBuilderF::new();
+                let mut gpu_buffer_builder = GpuBufferBuilder::new();
 
                 match task.kind {
                     RenderTaskKind::Picture(ref pic_task) => {
@@ -1134,8 +1127,7 @@ pub struct Frame {
 
     /// Main GPU data buffer constructed (primarily) during the prepare
     /// pass for primitives that were visible and dirty.
-    pub gpu_buffer_f: GpuBufferF,
-    pub gpu_buffer_i: GpuBufferI,
+    pub gpu_buffer: GpuBuffer,
 }
 
 impl Frame {

webrender/src/prepare.rs

@@ -32,7 +32,7 @@ use crate::render_task_graph::{RenderTaskId};
 use crate::render_task_cache::RenderTaskCacheKeyKind;
 use crate::render_task_cache::{RenderTaskCacheKey, to_cache_size, RenderTaskParent};
 use crate::render_task::{RenderTaskKind, RenderTask, SubPass, MaskSubPass, EmptyTask};
-use crate::renderer::{GpuBufferBuilderF, GpuBufferAddress};
+use crate::renderer::{GpuBufferBuilder, GpuBufferAddress};
 use crate::segment::{EdgeAaSegmentMask, SegmentBuilder};
 use crate::space::SpaceMapper;
 use crate::util::{clamp_to_scale_factor, pack_as_float, MaxRect};
@@ -452,7 +452,7 @@ fn prepare_interned_prim_for_render(
                         kind: RenderTaskCacheKeyKind::LineDecoration(cache_key.clone()),
                     },
                     frame_state.gpu_cache,
-                    frame_state.frame_gpu_data_f,
+                    frame_state.frame_gpu_data,
                     frame_state.rg_builder,
                     None,
                     false,
@@ -607,7 +607,7 @@ fn prepare_interned_prim_for_render(
                 handles.push(frame_state.resource_cache.request_render_task(
                     cache_key,
                     frame_state.gpu_cache,
-                    frame_state.frame_gpu_data_f,
+                    frame_state.frame_gpu_data,
                     frame_state.rg_builder,
                     None,
                     false,          // TODO(gw): We don't calculate opacity for borders yet!
@@ -764,7 +764,7 @@ fn prepare_interned_prim_for_render(
                 //           the written block count) to gpu-buffer, we could add a trait for
                 //           writing typed data?
                 let main_prim_address = write_prim_blocks(
-                    frame_state.frame_gpu_data_f,
+                    frame_state.frame_gpu_data,
                     prim_data.common.prim_rect,
                     prim_instance.vis.clip_chain.local_clip_rect,
                     premul_color,
@@ -1138,7 +1138,7 @@ fn prepare_interned_prim_for_render(
 
             let stops_address = GradientGpuBlockBuilder::build(
                 prim_data.reverse_stops,
-                frame_state.frame_gpu_data_f,
+                frame_state.frame_gpu_data,
                 &prim_data.stops,
             );
 
@@ -1297,7 +1297,7 @@ fn prepare_interned_prim_for_render(
                     .cast_unit();
 
                 let main_prim_address = write_prim_blocks(
-                    frame_state.frame_gpu_data_f,
+                    frame_state.frame_gpu_data,
                     prim_local_rect,
                     prim_instance.vis.clip_chain.local_clip_rect,
                     PremultipliedColorF::WHITE,
@@ -1820,7 +1820,7 @@ pub fn update_clip_task(
             root_spatial_node_index,
             frame_state.clip_store,
             frame_state.gpu_cache,
-            frame_state.frame_gpu_data_f,
+            frame_state.frame_gpu_data,
             frame_state.resource_cache,
             frame_state.rg_builder,
             &mut data_stores.clip,
@@ -1881,7 +1881,7 @@ pub fn update_brush_segment_clip_task(
         root_spatial_node_index,
         frame_state.clip_store,
         frame_state.gpu_cache,
-        frame_state.frame_gpu_data_f,
+        frame_state.frame_gpu_data,
         frame_state.resource_cache,
         frame_state.rg_builder,
         clip_data_store,
@@ -2117,7 +2117,7 @@ fn adjust_mask_scale_for_max_size(device_rect: DeviceRect, device_pixel_scale: D
 }
 
 pub fn write_prim_blocks(
-    builder: &mut GpuBufferBuilderF,
+    builder: &mut GpuBufferBuilder,
     prim_rect: LayoutRect,
     clip_rect: LayoutRect,
     color: PremultipliedColorF,
@@ -2223,7 +2223,7 @@ fn add_composite_prim(
     segments: &[QuadSegment],
 ) {
     let composite_prim_address = write_prim_blocks(
-        frame_state.frame_gpu_data_f,
+        frame_state.frame_gpu_data,
         rect,
         rect,
         color,

webrender/src/prim_store/gradient/conic.rs

@@ -254,7 +254,7 @@ impl ConicGradientTemplate {
                 kind: RenderTaskCacheKeyKind::ConicGradient(cache_key),
             },
             frame_state.gpu_cache,
-            frame_state.frame_gpu_data_f,
+            frame_state.frame_gpu_data,
             frame_state.rg_builder,
             None,
             false,