Implement support for 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 "GrGLStencilAttachment.h"
@@ skipping 355 matching lines @@
             // On some devices this may have a perf hit.  Also multiple render targets are disabled
             GL_CALL(Enable(GR_GL_FETCH_PER_SAMPLE_ARM));
         }
         fHWWriteToColor = kUnknown_TriState;
         // we only ever use lines in hairline mode
         GL_CALL(LineWidth(1));
     }
 
     if (resetBits & kMSAAEnable_GrGLBackendState) {
         fMSAAEnabled = kUnknown_TriState;
+        fCoverageModulationEnabled = kUnknown_TriState;

[Chris Dalton, 2015/06/09 17:39:51]

At this point we can just call:

 glCoverageModulationNV(GL_RGBA);

     }
 
     fHWActiveTextureUnitIdx = -1; // invalid
 
     if (resetBits & kTextureBinding_GrGLBackendState) {
         for (int s = 0; s < fHWBoundTextureUniqueIDs.count(); ++s) {
             fHWBoundTextureUniqueIDs[s] = SK_InvalidUniqueID;
         }
     }
 
@@ skipping 111 matching lines @@
     }
 
     return texture;
 }
 
 GrRenderTarget* GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc) {
     GrGLRenderTarget::IDDesc idDesc;
     idDesc.fRTFBOID = static_cast<GrGLuint>(wrapDesc.fRenderTargetHandle);
     idDesc.fMSColorRenderbufferID = 0;
     idDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID;
+    idDesc.fSampleConfig = (wrapDesc.fFlags & kStencilMSAAOnly_GrBackendRenderTargetFlags) ?

[Chris Dalton, 2015/06/09 17:39:51]

Here we ought to ignore the multisample stencil buffer if we don't have full
mixed samples support. (e.g. somebody gives us a multisample stencil but we
don't have dual source blending, so we opt to not ever use it.)

 ((wrapDesc.fFlags & kStencilMSAAOnly_GrBackendRenderTargetFlags) &&
  this->caps()->shaderCaps()->mixedSamplesSupport())

+                           GrRenderTarget::kStencil_SampleConfig :
+                           GrRenderTarget::kUnified_SampleConfig;
     idDesc.fLifeCycle = GrGpuResource::kWrapped_LifeCycle;
 
     GrSurfaceDesc desc;
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
     desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
     desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true);
 
@@ skipping 327 matching lines @@
 
 static bool renderbuffer_storage_msaa(const GrGLContext& ctx,
                                       int sampleCount,
                                       GrGLenum format,
                                       int width, int height) {
     CLEAR_ERROR_BEFORE_ALLOC(ctx.interface());
     SkASSERT(GrGLCaps::kNone_MSFBOType != ctx.caps()->msFBOType());
     switch (ctx.caps()->msFBOType()) {
         case GrGLCaps::kDesktop_ARB_MSFBOType:
         case GrGLCaps::kDesktop_EXT_MSFBOType:
+        case GrGLCaps::kMixedSamples_MSFBOType:
         case GrGLCaps::kES_3_0_MSFBOType:
             GL_ALLOC_CALL(ctx.interface(),
                             RenderbufferStorageMultisample(GR_GL_RENDERBUFFER,
                                                             sampleCount,
                                                             format,
                                                             width, height));
             break;
         case GrGLCaps::kES_Apple_MSFBOType:
             GL_ALLOC_CALL(ctx.interface(),
                             RenderbufferStorageMultisampleES2APPLE(GR_GL_RENDERBUFFER,
@@ skipping 17 matching lines @@
 }
 
 bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc,
                                         GrGpuResource::LifeCycle lifeCycle,
                                         GrGLuint texID,
                                         GrGLRenderTarget::IDDesc* idDesc) {
     idDesc->fMSColorRenderbufferID = 0;
     idDesc->fRTFBOID = 0;
     idDesc->fTexFBOID = 0;
     idDesc->fLifeCycle = lifeCycle;
+    idDesc->fSampleConfig = GrGLCaps::kMixedSamples_MSFBOType ==
+                            this->glCaps().msFBOType() ? GrRenderTarget::kStencil_SampleConfig :
+                                                         GrRenderTarget::kUnified_SampleConfig;
 
     GrGLenum status;
 
     GrGLenum msColorFormat = 0; // suppress warning
 
     if (desc.fSampleCnt > 0 && GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) {
         goto FAILED;
     }
 
     GL_CALL(GenFramebuffers(1, &idDesc->fTexFBOID));
@@ skipping 262 matching lines @@
 }
 }
 
 bool GrGLGpu::createStencilAttachmentForRenderTarget(GrRenderTarget* rt, int width, int height) {
     // All internally created RTs are also textures. We don't create
     // SBs for a client's standalone RT (that is a RT that isn't also a texture).
     SkASSERT(rt->asTexture());
     SkASSERT(width >= rt->width());
     SkASSERT(height >= rt->height());
 
-    int samples = rt->numSamples();
+    int samples = rt->numStencilSamples();
     GrGLStencilAttachment::IDDesc sbDesc;
 
     int stencilFmtCnt = this->glCaps().stencilFormats().count();
     for (int i = 0; i < stencilFmtCnt; ++i) {
         if (!sbDesc.fRenderbufferID) {
             GL_CALL(GenRenderbuffers(1, &sbDesc.fRenderbufferID));
         }
         if (!sbDesc.fRenderbufferID) {
             return false;
         }
@@ skipping 899 matching lines @@
                                stencilSettings,
                                GR_GL_FRONT_AND_BACK,
                                GrStencilSettings::kFront_Face);
             }
         }
         fHWStencilSettings = stencilSettings;
     }
 }
 
 void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA) {
-    SkASSERT(!useHWAA || rt->isMultisampled());
+    SkASSERT(!useHWAA || rt->isStencilBufferMultisampled());
 
-    if (this->glCaps().multisampleDisableSupport()) {
+    if (this->glCaps().multisampleDisableSupport() ||
+        this->glCaps().shaderCaps()->mixedSamplesSupport()) {

[Chris Dalton, 2015/06/09 17:39:52]

I would recommend rolling this into the multisampleDisableSupport cap, where
that cap is always true when we have mixed samples.

         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;
             }
         }
     }
+    if (this->glCaps().shaderCaps()->mixedSamplesSupport()) {
+        if (useHWAA && GrRenderTarget::kStencil_SampleConfig == rt->sampleConfig()) {
+            if (kYes_TriState != fCoverageModulationEnabled) {
+                GL_CALL(CoverageModulation(GR_GL_RGBA));
+                fCoverageModulationEnabled = kYes_TriState;
+            }
+        } else {
+            if (kNo_TriState != fCoverageModulationEnabled) {
+                GL_CALL(CoverageModulation(GR_GL_NONE));
+                fCoverageModulationEnabled = kNo_TriState;
+            }
+        }
+    }
 }
 
 void GrGLGpu::flushBlend(const GrXferProcessor::BlendInfo& blendInfo) {
     // Any optimization to disable blending should have already been applied and
     // tweaked the equation to "add" or "subtract", and the coeffs to (1, 0).
 
     GrBlendEquation equation = blendInfo.fEquation;
     GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
     GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
     bool blendOff = (kAdd_GrBlendEquation == equation || kSubtract_GrBlendEquation == equation) &&
@@ skipping 949 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }