Use texture barriers to read directly from the RT

src/gpu/GrDrawTarget.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawTarget.h"
 
@@ skipping 452 matching lines @@
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
 
         GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, gp, devBounds,
                                                 this);
         if (pipelineInfo.mustSkipDraw()) {
             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);
     }
 }
 
 void GrDrawTarget::drawNonIndexed(GrPipelineBuilder* pipelineBuilder,
                                   const GrGeometryProcessor* gp,
                                   GrPrimitiveType type,
                                   int startVertex,
@@ skipping 25 matching lines @@
         if (devBounds) {
             info.setDevBounds(*devBounds);
         }
 
         GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, gp, devBounds,
                                                 this);
         if (pipelineInfo.mustSkipDraw()) {
             return;
         }
 
+        if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+            this->onBlendBarrier();
+        }
+
         this->setDrawBuffers(&info, gp->getVertexStride());
 
         this->onDraw(gp, info, pipelineInfo);
     }
 }
 
 
 void GrDrawTarget::drawBatch(GrPipelineBuilder* pipelineBuilder,
                              GrBatch* batch,
                              const SkRect* devBounds) {
     SkASSERT(pipelineBuilder);
     // TODO some kind of checkdraw, but not at this level
 
     // Setup clip
     GrScissorState scissorState;
     GrPipelineBuilder::AutoRestoreFragmentProcessors arfp;
     GrPipelineBuilder::AutoRestoreStencil ars;
     if (!this->setupClip(pipelineBuilder, &arfp, &ars, &scissorState, devBounds)) {
         return;
     }
 
     GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, batch, devBounds, this);
     if (pipelineInfo.mustSkipDraw()) {
         return;
     }
 
+    if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+        this->onBlendBarrier();
+    }
+
     this->onDrawBatch(batch, pipelineInfo);
 }
 
 static const GrStencilSettings& winding_path_stencil_settings() {
     GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
         kIncClamp_StencilOp,
         kIncClamp_StencilOp,
         kAlwaysIfInClip_StencilFunc,
         0xFFFF, 0xFFFF, 0xFFFF);
     return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
@@ skipping 245 matching lines @@
                             info.fStartIndex,
                             info.fVertexCount,
                             info.fIndexCount)) {
 
             GrDrawTarget::PipelineInfo pipelineInfo(pipelineBuilder, &scissorState, gp, devBounds,
                                                     this);
             if (pipelineInfo.mustSkipDraw()) {
                 return;
             }
 
+            if (!pipelineBuilder->willBlendCoherently(*this->caps())) {
+                this->onBlendBarrier();
+            }
+
             this->setDrawBuffers(&info, gp->getVertexStride());
             this->onDraw(gp, info, pipelineInfo);
         }
         info.fStartVertex += info.fVertexCount;
         instanceCount -= info.fInstanceCount;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 440 matching lines @@
                              GrPipelineBuilder::AutoRestoreFragmentProcessors* arfp,
                              GrPipelineBuilder::AutoRestoreStencil* ars,
                              GrScissorState* scissorState,
                              const SkRect* devBounds) {
     return fClipMaskManager.setupClipping(pipelineBuilder,
                                           arfp,
                                           ars,
                                           scissorState,
                                           devBounds);
 }