Auto merge of servo#508 - glennw:blend-mode-prep, r=pcwalton

Add support for specific blend modes per batch.

Also track the previous blend mode while drawing batches
and only set it when changed.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/webrender/508)
<!-- Reviewable:end -->

Author: bors-servo

webrender/src/renderer.rs

@@ -88,6 +88,12 @@ const GPU_TAG_PRIM_BOX_SHADOW: GpuProfileTag = GpuProfileTag { label: "BoxShadow
 // Orange
 const GPU_TAG_PRIM_BORDER: GpuProfileTag = GpuProfileTag { label: "Border", color: ColorF { r: 1.0, g: 0.5, b: 0.0, a: 1.0 } };
 
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum BlendMode {
+    None,
+    Alpha,
+}
+
 struct VertexDataTexture {
     id: TextureId,
 }
@@ -1390,14 +1396,23 @@ impl Renderer {
                                 &projection);
         }
 
+        let mut prev_blend_mode = BlendMode::None;
+
         for batch in &target.alpha_batcher.batches {
             let color_texture_id = batch.key.color_texture_id;
             let mask_texture_id = batch.key.mask_texture_id;
             let transform_kind = batch.key.flags.transform_kind();
             let has_complex_clip = batch.key.flags.needs_clipping();
-            let blending_enabled = batch.key.flags.needs_blending();
 
-            self.device.set_blend(blending_enabled);
+            if batch.key.blend_mode != prev_blend_mode {
+                match batch.key.blend_mode {
+                    // TODO(gw): More blend modes to come with subpixel aa work.
+                    BlendMode::None | BlendMode::Alpha => {
+                        self.device.set_blend(batch.key.blend_mode == BlendMode::Alpha);
+                    }
+                }
+                prev_blend_mode = batch.key.blend_mode;
+            }
 
             match &batch.data {
                 &PrimitiveBatchData::Blend(ref ubo_data) => {

webrender/src/tiling.rs

@@ -20,6 +20,7 @@ use prim_store::{GradientPrimitiveCpu, GradientPrimitiveGpu, GradientType};
 use prim_store::{PrimitiveCacheKey, TextRunPrimitiveGpu, TextRunPrimitiveCpu};
 use prim_store::{PrimitiveStore, GpuBlock16, GpuBlock32, GpuBlock64, GpuBlock128};
 use profiler::FrameProfileCounters;
+use renderer::BlendMode;
 use resource_cache::ResourceCache;
 use resource_list::ResourceList;
 use std::cmp;
@@ -388,11 +389,16 @@ impl AlphaBatcher {
                                              !prim_metadata.is_opaque ||
                                              needs_clipping;
                         let flags = AlphaBatchKeyFlags::new(transform_kind,
-                                                            needs_blending,
                                                             needs_clipping);
+                        let blend_mode = if needs_blending {
+                            BlendMode::Alpha
+                        } else {
+                            BlendMode::None
+                        };
                         let batch_kind = ctx.prim_store.get_batch_kind(prim_metadata);
                         batch_key = AlphaBatchKey::primitive(batch_kind,
                                                              flags,
+                                                             blend_mode,
                                                              prim_metadata.color_texture_id,
                                                              prim_metadata.mask_texture_id);
                     }
@@ -805,6 +811,7 @@ enum AlphaBatchKind {
 pub struct AlphaBatchKey {
     kind: AlphaBatchKind,
     pub flags: AlphaBatchKeyFlags,
+    pub blend_mode: BlendMode,
     pub color_texture_id: TextureId,
     pub mask_texture_id: TextureId,
 }
@@ -814,8 +821,8 @@ impl AlphaBatchKey {
         AlphaBatchKey {
             kind: AlphaBatchKind::Blend,
             flags: AlphaBatchKeyFlags::new(TransformedRectKind::AxisAligned,
-                                           true,
                                            false),
+            blend_mode: BlendMode::Alpha,
             color_texture_id: TextureId::invalid(),
             mask_texture_id: TextureId::invalid(),
         }
@@ -825,21 +832,23 @@ impl AlphaBatchKey {
         AlphaBatchKey {
             kind: AlphaBatchKind::Composite,
             flags: AlphaBatchKeyFlags::new(TransformedRectKind::AxisAligned,
-                                           true,
                                            false),
+            blend_mode: BlendMode::Alpha,
             color_texture_id: TextureId::invalid(),
             mask_texture_id: TextureId::invalid(),
         }
     }
 
     fn primitive(kind: AlphaBatchKind,
                  flags: AlphaBatchKeyFlags,
+                 blend_mode: BlendMode,
                  color_texture_id: TextureId,
                  mask_texture_id: TextureId)
                  -> AlphaBatchKey {
         AlphaBatchKey {
             kind: kind,
             flags: flags,
+            blend_mode: blend_mode,
             color_texture_id: color_texture_id,
             mask_texture_id: mask_texture_id,
         }
@@ -862,11 +871,9 @@ pub struct AlphaBatchKeyFlags(u8);
 
 impl AlphaBatchKeyFlags {
     fn new(transform_kind: TransformedRectKind,
-           needs_blending: bool,
            needs_clipping: bool) -> AlphaBatchKeyFlags {
-        AlphaBatchKeyFlags( ((needs_clipping as u8) << 2) |
-                            ((transform_kind as u8) << 1) |
-                            ((needs_blending as u8) << 0) )
+        AlphaBatchKeyFlags( ((transform_kind as u8) << 1) |
+                            ((needs_clipping as u8) << 0) )
     }
 
     pub fn transform_kind(&self) -> TransformedRectKind {
@@ -877,12 +884,8 @@ impl AlphaBatchKeyFlags {
         }
     }
 
-    pub fn needs_blending(&self) -> bool {
-        (self.0 & 1) != 0
-    }
-
     pub fn needs_clipping(&self) -> bool {
-        (self.0 & 4) != 0
+        (self.0 & 1) != 0
     }
 }