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 283 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;
     }
 
     fHWActiveTextureUnitIdx = -1; // invalid
 
     if (resetBits & kTextureBinding_GrGLBackendState) {
         for (int s = 0; s < fHWBoundTextureUniqueIDs.count(); ++s) {
             fHWBoundTextureUniqueIDs[s] = SK_InvalidUniqueID;
         }
     }
 
@@ skipping 114 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) ?
+                           GrRenderTarget::kStencil_SampleConfig : GrRenderTarget::kUnified_SampleConfig;

[Chris Dalton, 2015/04/07 23:48:23]

Looks like we broke 100 columns...

[vbuzinov, 2015/04/08 12:05:30]

Done.

     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(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 16 matching lines @@
     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->fRTFBOID = 0;
     idDesc->fTexFBOID = 0;
     idDesc->fLifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
                                     GrGpuResource::kUncached_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 301 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(GrRenderTarget::BufferBits::kStencil_BufferBit);
     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 936 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->isMultisampled(GrRenderTarget::BufferBits::kAny_BufferBits));
 
-    if (kGL_GrGLStandard == this->glStandard()) {
+    if (kGL_GrGLStandard == this->glStandard() ||
+        this->glCaps().fbMixedSamplesSupport()) {
         if (useHWAA) {
             if (kYes_TriState != fMSAAEnabled) {
                 GL_CALL(Enable(GR_GL_MULTISAMPLE));

[Mark Kilgard, 2015/04/08 03:20:09]

warning: enabling/disabling GL_MULTISAMPLE is not officially supported in OpenGL
ES 2.x/3.x

NVIDIA has an accidental allowance (technically a bug) where the Tegra K1 & X1
ES drivers (and desktop ES contexts too) allow GL_MULTISAMPLE to be
enabled/disabled.

We are working to standardize an extension to be called
EXT_multisample_compatibility that will, when advertised, allow GL_MULTISAMPLE
(and GL_SAMPLE_ALPHA_TO_ONE) to be enabled/disabled.

Intel is a likely partner for the EXT.  I should send the specification to
Google's Skia team for their consideration too.  Any OpenGL 1.3 capable hardware
(though not ES-only hardware) should be able to support
EXT_multisample_compatibility.  It has many advantages for ensuring aliased
behavior and is useful with NV_framebuffer_mixed_samples in particular in
certain cases.

If the proposed EXT_multisample_compatibility extension is not advertised and
some NV-only extension such as NV_blend_equation_advanced (K1 or X1) or
NV_framebuffer_mixed_samples (K1 only) is supported, you can try to call
glEnable(GL_MULTISAMPLE).  If there is no GL_INVALID_ENUM error, assume
EXT_multisample_compatibility is de facto supported.

Note: the default GL_MULTISAMPLE state is enabled (and ES acts that way, just
with no way to do the disable).  

[vbuzinov, 2015/04/08 12:05:30]

Doesn't look like there was an explicit check for whether the context is GLES
here before our modification.  Of course, only with Nvfms multisampling will
actually be toggled.  We can add the ES and a caps check here when this
extension is available, but right now we actually depend on this "bug" to render
things properly...

                 fMSAAEnabled = kYes_TriState;
             }
         } else {
             if (kNo_TriState != fMSAAEnabled) {
                 GL_CALL(Disable(GR_GL_MULTISAMPLE));
                 fMSAAEnabled = kNo_TriState;
             }
         }
     }
+    if (this->glCaps().fbMixedSamplesSupport()) {
+        if (useHWAA && GrRenderTarget::kStencil_SampleConfig == rt->sampleConfig()) {
+            if (kYes_TriState != fCoverageModulationEnabled) {

[Mark Kilgard, 2015/04/08 03:20:09]

...technically this mode isn't an enable though Skia may use it that way

+                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 coeffs to (1, 0).
     
     GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
     GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
     bool blendOff = kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff;
     if (blendOff) {
@@ skipping 692 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }