Fix mixed samples stencil clip

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
@@ skipping 1474 matching lines @@
 
     int numTextureAccesses = textureAccesses.count();
     for (int i = 0; i < numTextureAccesses; i++) {
         this->bindTexture(i, textureAccesses[i]->getParams(),
                           static_cast<GrGLTexture*>(textureAccesses[i]->getTexture()));
     }
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(pipeline.getRenderTarget());
     this->flushStencil(pipeline.getStencil());
     this->flushScissor(pipeline.getScissorState(), glRT->getViewport(), glRT->origin());
-    this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), !pipeline.getStencil().isDisabled());
+    this->flushHWAAState(glRT, pipeline.isHWAntialiasState());
 
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
-    this->flushRenderTarget(glRT, nullptr);
+    this->flushRenderTarget(glRT, nullptr, pipeline.hasCoCenteredSamples());
 
     return true;
 }
 
 void GrGLGpu::setupGeometry(const GrPrimitiveProcessor& primProc,
                             const GrNonInstancedVertices& vertices,
                             size_t* indexOffsetInBytes) {
     GrGLVertexBuffer* vbuf;
     vbuf = (GrGLVertexBuffer*) vertices.vertexBuffer();
 
@@ skipping 509 matching lines @@
             if (!flipY) {
                 dst += rowBytes;
             } else {
                 dst -= rowBytes;
             }
         }
     }
     return true;
 }
 
-void GrGLGpu::setColocatedSampleLocations(GrRenderTarget* rt, bool useColocatedSampleLocations) {
-    GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt->asRenderTarget());
-    SkASSERT(0 != target->renderFBOID());
-
-    if (!rt->isStencilBufferMultisampled() ||
-        useColocatedSampleLocations == target->usesColocatedSampleLocations()) {
-        return;
-    }
-
-    if (kGL_GrGLStandard == this->glStandard() && this->glVersion() >= GR_GL_VER(4,5)) {
-        GL_CALL(NamedFramebufferParameteri(target->renderFBOID(),
-                                           GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS,
-                                           useColocatedSampleLocations));
-    } else {
-        GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, target->renderFBOID()));
-        GL_CALL(FramebufferParameteri(GR_GL_FRAMEBUFFER,
-                                      GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS,
-                                      useColocatedSampleLocations));
-        fHWBoundRenderTargetUniqueID = SK_InvalidUniqueID;
-    }
-
-    target->flagAsUsingColocatedSampleLocations(useColocatedSampleLocations);
-}
-
-void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound) {
-
+void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound,
+                                bool coCenterSamples) {
     SkASSERT(target);
+    SkASSERT(!coCenterSamples || this->caps()->programmableSampleLocationsSupport());
 
     uint32_t rtID = target->getUniqueID();
     if (fHWBoundRenderTargetUniqueID != rtID) {
         fStats.incRenderTargetBinds();
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, target->renderFBOID()));
 #ifdef SK_DEBUG
         // don't do this check in Chromium -- this is causing
         // lots of repeated command buffer flushes when the compositor is
         // rendering with Ganesh, which is really slow; even too slow for
         // Debug mode.
@@ skipping 23 matching lines @@
         }
     }
     if (nullptr == bound || !bound->isEmpty()) {
         target->flagAsNeedingResolve(bound);
     }
 
     GrTexture *texture = target->asTexture();
     if (texture) {
         texture->texturePriv().dirtyMipMaps(true);
     }
+
+    if (this->caps()->programmableSampleLocationsSupport()) {
+        ResetTimestamp timestamp;
+        bool hasCoCenteredSamples = target->getCachedCoCenteredSamplesState(&timestamp);
+        if (timestamp < this->getResetTimestamp() || hasCoCenteredSamples != coCenterSamples) {
+            // The default state for programmable sample locations is already at pixel center, so we
+            // don't assign them. This assumes the client does not modify them outside of Skia.
+            GL_CALL(FramebufferParameteri(GR_GL_FRAMEBUFFER,
+                                          GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS,
+                                          coCenterSamples));
+            target->setCachedCoCenteredSamplesState(coCenterSamples, this->getResetTimestamp());
+        }
+    }
 }
 
 GrGLenum gPrimitiveType2GLMode[] = {
     GR_GL_TRIANGLES,
     GR_GL_TRIANGLE_STRIP,
     GR_GL_TRIANGLE_FAN,
     GR_GL_POINTS,
     GR_GL_LINES,
     GR_GL_LINE_STRIP
 };
@@ skipping 181 matching lines @@
                 set_gl_stencil(this->glInterface(),
                                stencilSettings,
                                GR_GL_FRONT_AND_BACK,
                                GrStencilSettings::kFront_Face);
             }
         }
         fHWStencilSettings = stencilSettings;
     }
 }
 
-void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool stencilEnabled) {
+void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA) {
     SkASSERT(!useHWAA || rt->isStencilBufferMultisampled());
 
-    if (rt->hasMixedSamples() && stencilEnabled &&
-        this->glCaps().glslCaps()->programmableSampleLocationsSupport()) {
-        if (useHWAA) {
-            this->setColocatedSampleLocations(rt, false);
-        } else {
-            this->setColocatedSampleLocations(rt, true);
-        }
-        useHWAA = true;
-    }
-
-    if (this->glCaps().multisampleDisableSupport()) {
+    if (this->caps()->multisampleDisableSupport()) {
         if (useHWAA) {
             if (kYes_TriState != fMSAAEnabled) {
                 GL_CALL(Enable(GR_GL_MULTISAMPLE));
                 fMSAAEnabled = kYes_TriState;
             }
         } else {
             if (kNo_TriState != fMSAAEnabled) {
                 GL_CALL(Disable(GR_GL_MULTISAMPLE));
                 fMSAAEnabled = kNo_TriState;
             }
@@ skipping 780 matching lines @@
 
     GL_CALL(Uniform4f(fCopyProgram.fPosXformUniform, dx1 - dx0, dy1 - dy0, dx0, dy0));
     GL_CALL(Uniform4f(fCopyProgram.fTexCoordXformUniform, sx1 - sx0, sy1 - sy0, sx0, sy0));
     GL_CALL(Uniform1i(fCopyProgram.fTextureUniform, 0));
 
     GrXferProcessor::BlendInfo blendInfo;
     blendInfo.reset();
     this->flushBlend(blendInfo);
     this->flushColorWrite(true);
     this->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
-    this->flushHWAAState(dstRT, false, false);
+    this->flushHWAAState(dstRT, false);
     this->disableScissor();
     GrStencilSettings stencil;
     stencil.setDisabled();
     this->flushStencil(stencil);
 
     GL_CALL(DrawArrays(GR_GL_TRIANGLE_STRIP, 0, 4));
 }
 
 void GrGLGpu::copySurfaceAsCopyTexSubImage(GrSurface* dst,
                                            GrSurface* src,
@@ skipping 203 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }