Enable stencil clipping in mixed sampled render targets

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 139 matching lines @@
 
     GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
     GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
     GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
     GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
 
     // assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
     GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gXfermodeCoeff2Blend));
 }
 
+// Sample locations that are colocated at pixel center.
+static const GrGLfloat gCenteredSampleLocations[2*16] = { 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
+                                                          0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
+                                                          0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f,
+                                                          0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f };
+
+// Default sample pattern.
+static GrGLfloat defaultSampleLocations2x[]  = { 0.75f, 0.75f, 0.25f, 0.25f };
+static GrGLfloat defaultSampleLocations4x[]  = { 0.375f, 0.125f, 0.875f, 0.375f, 0.125f, 0.625f, 0.625f, 0.875f };
+static GrGLfloat defaultSampleLocations8x[]  = { 0.5625f, 0.3125f, 0.4375f, 0.6875f, 0.8125f, 0.5625f, 0.3125f, 0.1875f,
+                                                 0.1875f, 0.8125f, 0.0625f, 0.4375f, 0.6875f, 0.9375f, 0.9375f, 0.0625f };
+static GrGLfloat defaultSampleLocations16x[] = { 0.5625f, 0.5625f, 0.4375f, 0.3125f, 0.3125f, 0.625f, 0.75f, 0.4375f,
+                                                 0.1875f, 0.375f, 0.625f, 0.8125f, 0.8125f, 0.6875f, 0.6875f, 0.1875f,
+                                                 0.375f, 0.875f, 0.5f, 0.0625f, 0.25f, 0.125f, 0.125f, 0.75f,
+                                                 0.375f, 0.875f, 0.5f, 0.0625f, 0.25f, 0.125f, 0.125f, 0.75f,
+                                                 0.0f, 0.5f, 0.9375f, 0.25f, 0.875f, 0.9375f, 0.0625f, 0.0f };
+// Lookup table for sample locations array for sample count 0..16.
+static GrGLfloat* gDefaultSampleLocations[17] = { 0,
+                                                  0, defaultSampleLocations2x, 0, defaultSampleLocations4x,
+                                                  0, 0, 0, defaultSampleLocations8x,
+                                                  0, 0, 0, 0,
+                                                  0, 0, 0, defaultSampleLocations16x };
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // Used in the map of pixel configs to stencil format indices. This value is used to
 // indicate that a stencil format has not yet been set for the given config.
 static const int kUnknownStencilIndex = -1;
 // This value is used as the stencil index when no stencil configs are supported with the
 // given pixel config.
 static const int kUnsupportedStencilIndex = -2;
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 1300 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());
+    this->flushHWAAState(glRT, pipeline.isHWAntialiasState(), !pipeline.getStencil().isDisabled());
 
     // 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);
 
     return true;
 }
 
 void GrGLGpu::setupGeometry(const GrPrimitiveProcessor& primProc,
                             const GrNonInstancedVertices& vertices,
@@ skipping 402 matching lines @@
             if (!flipY) {
                 dst += rowBytes;
             } else {
                 dst -= rowBytes;
             }
         }
     }
     return true;
 }
 
+void GrGLGpu::setCenteredSampleLocations(GrRenderTarget* rt, bool useCenteredSampleLocations) {
+    GrGLRenderTarget* target = static_cast<GrGLRenderTarget*>(rt->asRenderTarget());
+    SkASSERT(0 != target->renderFBOID());
+
+    if (0 == rt->numRasterSamples() ||
+        useCenteredSampleLocations == rt->renderTargetPriv().usesCenteredSampleLocations()) {
+        return;
+    }
+
+    if (!rt->renderTargetPriv().programmableSampleLocationsEnabled()) {
+        GL_CALL(NamedFramebufferParameteri(target->renderFBOID(),
+                                           GR_GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS, true));
+        rt->renderTargetPriv().setProgrammableSampleLocationsEnabled(true);
+    }
+
+    SkASSERT(rt->numRasterSamples() == 2 ||
+             rt->numRasterSamples() == 4 ||
+             rt->numRasterSamples() == 8 ||
+             rt->numRasterSamples() == 16);
+
+    const GrGLfloat *sampleLocations =
+        useCenteredSampleLocations ? gCenteredSampleLocations
+                                   : gDefaultSampleLocations[rt->numRasterSamples()];
+    GL_CALL(NamedFramebufferSampleLocationsfv(target->renderFBOID(), 0, rt->numRasterSamples(), sampleLocations));
+    rt->renderTargetPriv().flagAsUsingCenteredSampleLocations(useCenteredSampleLocations);
+}
+
 void GrGLGpu::flushRenderTarget(GrGLRenderTarget* target, const SkIRect* bound) {
 
     SkASSERT(target);
 
     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
@@ skipping 227 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) {
+void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool stencilEnabled) {
     SkASSERT(!useHWAA || rt->isStencilBufferMultisampled());
 
+    if (rt->hasMixedSamples() && stencilEnabled &&
+        this->glCaps().glslCaps()->programmableSampleLocationsSupport()) {
+        if (useHWAA) {
+            setCenteredSampleLocations(rt, false);
+        } else {
+            setCenteredSampleLocations(rt, true);
+        }
+        useHWAA = true;
+    }
+
     if (this->glCaps().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 762 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->flushDither(false);
     this->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
-    this->flushHWAAState(dstRT, false);
+    this->flushHWAAState(dstRT, false, 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 214 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }