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 "GrGLStencilBuffer.h"
@@ skipping 332 matching lines @@
     if (resetBits & kRenderTarget_GrGLBackendState) {
         for (size_t i = 0; i < SK_ARRAY_COUNT(fHWFBOBinding); ++i) {
             fHWFBOBinding[i].invalidate();
         }
     }
 
     if (resetBits & kPathRendering_GrGLBackendState) {
         if (this->caps()->pathRenderingSupport()) {
             this->glPathRendering()->resetContext();
         }
+        if (this->glCaps().fbMixedSamplesSupport()) {
+            GL_CALL(CoverageModulation(GR_GL_RGBA));

[Chris Dalton, 2015/03/12 07:43:35]

Let's verify there isn't a performance penalty to leaving this always enabled.
If there is, we will want to only enable as needed (at the same time we
enable/disable MULTISAMPLE).

Also, I don't think this belongs under PathRendering. I'd probably put it under
kBlend_GrGLBackendState, or _maybe_ kMSAAEnable_GrGLBackendState.

[Chris Dalton, 2015/03/12 08:04:52]

One more thing:

The coverage modulation we use may depend on the blending mode. Premultiplied
alpha would use GL_RGBA, whereas not-premultiplied alpha would need GL_ALPHA.
Have you thought this through and figured that GL_RGBA is always the correct
mode for skia? If not, Skia has already solved this problem for their own
coverage modulation so we chould just copy how they do it.

[vbuzinov, 2015/03/13 13:37:22]

1-Done. 2-Not done

+        }
     }
 
     // we assume these values
     if (resetBits & kPixelStore_GrGLBackendState) {
         if (this->glCaps().unpackRowLengthSupport()) {
             GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
         }
         if (this->glCaps().packRowLengthSupport()) {
             GL_CALL(PixelStorei(GR_GL_PACK_ROW_LENGTH, 0));
         }
@@ skipping 77 matching lines @@
     }
 
     return texture;
 }
 
 GrRenderTarget* GrGLGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc) {
     GrGLRenderTarget::IDDesc idDesc;
     GrGLuint fboID = static_cast<GrGLuint>(wrapDesc.fRenderTargetHandle);
     idDesc.fRenderFBO.reset(SkNEW_ARGS(GrGLFBO, (fboID)));
     idDesc.fMSColorRenderbufferID = 0;
+    idDesc.fSampleConfig = wrapDesc.fSampleConfig;
     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 = wrapDesc.fSampleCnt;
     desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true);
 
@@ skipping 327 matching lines @@
 
 static bool renderbuffer_storage_msaa(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::kStencil_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 14 matching lines @@
             break;
     }
     return (GR_GL_NO_ERROR == CHECK_ALLOC_ERROR(ctx.interface()));;
 }
 
 bool GrGLGpu::createRenderTargetObjects(const GrSurfaceDesc& desc, bool budgeted, GrGLuint texID,
                                         GrGLRenderTarget::IDDesc* idDesc) {
     idDesc->fMSColorRenderbufferID = 0;
     idDesc->fLifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
                                     GrGpuResource::kUncached_LifeCycle;
+    idDesc->fSampleConfig = GrGLCaps::kStencil_MSFBOType ==
+                            this->glCaps().msFBOType() ? kStencil_GrSampleConfig :
+                                                         kUnified_GrSampleConfig;
 
     GrGLenum status;
 
     GrGLenum msColorFormat = 0; // suppress warning
     GrGLenum fboTarget = 0; // suppress warning
 
     if (desc.fSampleCnt > 0 && GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) {
         goto FAILED;
     }
 
@@ skipping 299 matching lines @@
 }
 }
 
 bool GrGLGpu::createStencilBufferForRenderTarget(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->numSamples(kStencil_GrSampleConfig);
     GrGLStencilBuffer::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 933 matching lines @@
     }
 }
 
 void GrGLGpu::flushHWAAState(GrRenderTarget* rt, bool useHWAA, bool isLineDraw) {
 // At least some ATI linux drivers will render GL_LINES incorrectly when MSAA state is enabled but
 // the target is not multisampled. Single pixel wide lines are rendered thicker than 1 pixel wide.
 #if 0
     // Replace RT_HAS_MSAA with this definition once this driver bug is no longer a relevant concern
     #define RT_HAS_MSAA rt->isMultisampled()
 #else
-    #define RT_HAS_MSAA (rt->isMultisampled() || isLineDraw)
+    #define RT_HAS_MSAA (rt->isMultisampled(kStencil_GrSampleConfig) || isLineDraw)

[Chris Dalton, 2015/03/12 07:43:35]

This feels awkward to check the stencil. Ideally there would be way to ask "Do
you have multisampling anywhere?"

Also don't forget to fix the line above in the #if 0

 #endif
 
     if (kGL_GrGLStandard == this->glStandard()) {
         if (RT_HAS_MSAA) {
             if (useHWAA) {
                 if (kYes_TriState != fMSAAEnabled) {
                     GL_CALL(Enable(GR_GL_MULTISAMPLE));
                     fMSAAEnabled = kYes_TriState;
                 }
             } else {
@@ skipping 707 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }