Merged the instance structs

webrender/res/prim_shared.glsl

@@ -642,33 +642,6 @@ BoxShadow fetch_boxshadow(int index) {
     return bs;
 }
 
-struct Blend {
-    ivec4 src_id_target_id_op_amount;
-};
-
-Blend fetch_blend(int index) {
-    Blend blend;
-
-    int offset = index * 1;
-    blend.src_id_target_id_op_amount = int_data[offset + 0];
-
-    return blend;
-}
-
-struct Composite {
-    ivec4 src0_src1_target_id_op;
-};
-
-Composite fetch_composite(int index) {
-    Composite composite;
-
-    int offset = index * 1;
-
-    composite.src0_src1_target_id_op = int_data[offset + 0];
-
-    return composite;
-}
-
 void write_clip(vec2 global_pos, ClipArea area) {
     vec2 texture_size = textureSize(sCache, 0).xy;
     vec2 uv = global_pos + area.task_bounds.xy - area.screen_origin_target_index.xy;

webrender/res/ps_blend.vs.glsl

@@ -3,6 +3,22 @@
  * 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/. */
 
+struct Blend {
+    ivec4 src_id_target_id_op_amount;
+};
+
+Blend fetch_blend(int index) {
+    PrimitiveInstance pi = fetch_instance(index);
+
+    Blend blend;
+    blend.src_id_target_id_op_amount = ivec4(pi.user_data.x,
+                                             pi.render_task_index,
+                                             pi.sub_index,
+                                             pi.user_data.y);
+
+    return blend;
+}
+
 void main(void) {
     Blend blend = fetch_blend(gl_InstanceID);
     Tile src = fetch_tile(blend.src_id_target_id_op_amount.x);

webrender/res/ps_composite.vs.glsl

@@ -3,6 +3,21 @@
  * 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/. */
 
+struct Composite {
+    ivec4 src0_src1_target_id_op;
+};
+
+Composite fetch_composite(int index) {
+    PrimitiveInstance pi = fetch_instance(index);
+
+    Composite composite;
+    composite.src0_src1_target_id_op = ivec4(pi.user_data.xy,
+                                             pi.render_task_index,
+                                             pi.sub_index);
+
+    return composite;
+}
+
 void main(void) {
     Composite composite = fetch_composite(gl_InstanceID);
     Tile src0 = fetch_tile(composite.src0_src1_target_id_op.x);

webrender/src/renderer.rs

@@ -369,8 +369,7 @@ pub struct Renderer {
     tile_clear_shader: LazilyCompiledShader,
 
     max_clear_tiles: usize,
-    max_prim_blends: usize,
-    max_prim_composites: usize,
+    max_prim_instances: usize,
     max_cache_instances: usize,
     max_clip_instances: usize,
     max_blurs: usize,
@@ -465,8 +464,6 @@ impl Renderer {
         let max_prim_instances = get_ubo_max_len::<tiling::PrimitiveInstance>(max_ubo_size);
         let max_cache_instances = get_ubo_max_len::<tiling::CachePrimitiveInstance>(max_ubo_size);
         let max_clip_instances = get_ubo_max_len::<tiling::CacheClipInstance>(max_ubo_size);
-        let max_prim_blends = get_ubo_max_len::<tiling::PackedBlendPrimitive>(max_ubo_size);
-        let max_prim_composites = get_ubo_max_len::<tiling::PackedCompositePrimitive>(max_ubo_size);
         let max_blurs = get_ubo_max_len::<tiling::BlurCommand>(max_ubo_size);
 
         let cs_box_shadow = LazilyCompiledShader::new(ShaderKind::Cache,
@@ -741,8 +738,7 @@ impl Renderer {
             ps_blend: ps_blend,
             ps_composite: ps_composite,
             max_clear_tiles: max_clear_tiles,
-            max_prim_blends: max_prim_blends,
-            max_prim_composites: max_prim_composites,
+            max_prim_instances: max_prim_instances,
             max_cache_instances: max_cache_instances,
             max_clip_instances: max_clip_instances,
             max_blurs: max_blurs,
@@ -1287,7 +1283,7 @@ impl Renderer {
                 &PrimitiveBatchData::Blend(ref ubo_data) => {
                     self.gpu_profile.add_marker(GPU_TAG_PRIM_BLEND);
                     let shader = self.ps_blend.get(&mut self.device);
-                    let max_prim_items = self.max_prim_blends;
+                    let max_prim_items = self.max_prim_instances;
                     self.draw_ubo_batch(ubo_data, shader,
                                         1,
                                         &batch.key.textures,
@@ -1297,7 +1293,7 @@ impl Renderer {
                 &PrimitiveBatchData::Composite(ref ubo_data) => {
                     self.gpu_profile.add_marker(GPU_TAG_PRIM_COMPOSITE);
                     let shader = self.ps_composite.get(&mut self.device);
-                    let max_prim_items = self.max_prim_composites;
+                    let max_prim_items = self.max_prim_instances;
 
                     // The composite shader only samples from sCache.
                     debug_assert!(cache_texture.is_some());

webrender/src/tiling.rs

@@ -1415,20 +1415,30 @@ pub struct PrimitiveInstance {
     user_data: [i32; 2],
 }
 
-#[derive(Debug, Clone)]
-pub struct PackedBlendPrimitive {
-    src_task_id: i32,
-    target_task_id: i32,
-    op: i32,
-    amount: i32,
-}
+impl PrimitiveInstance {
+    fn blend(src_task_id: i32, target_task_id: i32, op: i32, amount: i32) -> PrimitiveInstance {
+        PrimitiveInstance {
+            global_prim_id: -1,
+            prim_address: GpuStoreAddress(0),
+            task_index: target_task_id,
+            clip_task_index: -1,
+            layer_index: -1,
+            sub_index: op,
+            user_data: [src_task_id, amount],
+        }
+    }
 
-#[derive(Debug)]
-pub struct PackedCompositePrimitive {
-    src0_task_id: i32,
-    src1_task_id: i32,
-    target_task_id: i32,
-    op: i32,
+    fn composite(src_tasks_id: [i32; 2], target_task_id: i32, op: i32) -> PrimitiveInstance {
+        PrimitiveInstance {
+            global_prim_id: -1,
+            prim_address: GpuStoreAddress(0),
+            task_index: target_task_id,
+            clip_task_index: -1,
+            layer_index: -1,
+            sub_index: op,
+            user_data: src_tasks_id,
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -1442,8 +1452,8 @@ pub enum PrimitiveBatchData {
     AngleGradient(Vec<PrimitiveInstance>),
     BoxShadow(Vec<PrimitiveInstance>),
     CacheImage(Vec<PrimitiveInstance>),
-    Blend(Vec<PackedBlendPrimitive>),
-    Composite(Vec<PackedCompositePrimitive>),
+    Blend(Vec<PrimitiveInstance>),
+    Composite(Vec<PrimitiveInstance>),
 }
 
 #[derive(Debug)]
@@ -1485,13 +1495,10 @@ impl PrimitiveBatch {
                     LowLevelFilterOp::Opacity(amount) => (8, amount.to_f32_px()),
                 };
 
-                ubo_data.push(PackedBlendPrimitive {
-                    src_task_id: src_rect_index.0 as i32,
-                    target_task_id: target_rect_index.0 as i32,
-                    amount: (amount * 65535.0).round() as i32,
-                    op: filter_mode,
-                });
-
+                ubo_data.push(PrimitiveInstance::blend(src_rect_index.0 as i32,
+                                                       target_rect_index.0 as i32,
+                                                       filter_mode,
+                                                       (amount * 65535.0).round() as i32));
                 true
             }
             _ => false
@@ -1505,13 +1512,10 @@ impl PrimitiveBatch {
                       info: MixBlendMode) -> bool {
         match &mut self.data {
             &mut PrimitiveBatchData::Composite(ref mut ubo_data) => {
-                ubo_data.push(PackedCompositePrimitive {
-                    src0_task_id: rect0_index.0 as i32,
-                    src1_task_id: rect1_index.0 as i32,
-                    target_task_id: target_rect_index.0 as i32,
-                    op: info as i32,
-                });
-
+                ubo_data.push(PrimitiveInstance::composite([rect0_index.0 as i32,
+                                                            rect1_index.0 as i32],
+                                                           target_rect_index.0 as i32,
+                                                           info as i32));
                 true
             }
             _ => false