Use texture barriers to read directly from the RT

src/gpu/GrDrawTarget.cpp

Index: src/gpu/GrDrawTarget.cpp
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index 420f9eae669f71dc9a12b69da08ebac28a3b933a..86b75d518590a40c91181e7676a97cb2f49b68ab 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -470,6 +470,10 @@ void GrDrawTarget::drawIndexed(GrPipelineBuilder* pipelineBuilder,
             return;
         }
 
+        if (!pipelineBuilder->willBlendCoherently(*this->caps())) {

[egdaniel, 2015/03/31 14:23:41]

So I feel like somewhere we need to be checking the caps to make sure we support
adding a Barrier. I know there is an assert right before the GL call but I think
we should protect ourselves from adding a barrier into the command buffer if we
don't support it. So maybe here we also check the the caps along with
willBlendCoherently(). If we don't have support and willBlendCohernetly returns
false then we need to figure out what our fall back is. I don't think it is safe
enough to assume willBlendCoherently() will only return false if there is caps
support (unless maybe it is checked in a non virtual version of it but that kind
of changes the meaning of the function call if you check the caps support).

Maybe a better name for willBlendCoherently is
requiresBarrierToBlendCoherently() and then a caller is responsible for making
sure they can insert a Barrier if needed.

[Chris Dalton, 2015/03/31 17:06:42]

That seems fine. What about "requiresBlendBarrier()"? Do you have a strong
preference for the name? We can just bail from onBlendBarrier in the event that
we don't have support. We shouldn't need a fallback because if we don't have
blend barriers, the xpf is obviously mistaken as it couldn't possibly be using a
blend mode that requires a barrier.

Just brainstorming here, but another option could be a virtual method where the
subclass inserts its blend barrier instead returning whether it needs one? That
could potentially be useful if we start having different types of blend barriers
(e.g. glTextureBarrier)...

[Mark Kilgard, 2015/04/02 23:02:38]

Two cents: I like the shorter requiresBlendBarrier to
requiresBarrierToBlendCoherently.

Chris, you don't want or need to use blend barriers for "conventional"
(non-advanced) blend modes.

Maybe I'll see that the pipelineBuilder has this knowledge...

+            this->onBlendBarrier();
+        }
+
         this->setDrawBuffers(&info, gp->getVertexStride());
 
         this->onDraw(gp, info, pipelineInfo);
@@ -515,6 +519,10 @@ void GrDrawTarget::drawNonIndexed(GrPipelineBuilder* pipelineBuilder,
             return;
         }
 
+        if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+            this->onBlendBarrier();
+        }
+
         this->setDrawBuffers(&info, gp->getVertexStride());
 
         this->onDraw(gp, info, pipelineInfo);
@@ -541,6 +549,10 @@ void GrDrawTarget::drawBatch(GrPipelineBuilder* pipelineBuilder,
         return;
     }
 
+    if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+        this->onBlendBarrier();
+    }
+
     this->onDrawBatch(batch, pipelineInfo);
 }
 
@@ -806,6 +818,10 @@ void GrDrawTarget::drawIndexedInstances(GrPipelineBuilder* pipelineBuilder,
                 return;
             }
 
+            if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+                this->onBlendBarrier();
+            }
+
             this->setDrawBuffers(&info, gp->getVertexStride());
             this->onDraw(gp, info, pipelineInfo);
         }