Add support for IMG's MSAA extension.

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 267 matching lines @@
 
     // Enable supported shader-related caps
     if (kDesktop_GrGLBinding == this->glBinding()) {
         caps->fDualSourceBlendingSupport = this->glVersion() >= GR_GL_VER(3,3) ||
                                            this->hasExtension("GL_ARB_blend_func_extended");
         caps->fShaderDerivativeSupport = true;
         // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
         caps->fGeometryShaderSupport = this->glVersion() >= GR_GL_VER(3,2) &&
                                        this->glslGeneration() >= k150_GrGLSLGeneration;
     } else {
-        caps->fShaderDerivativeSupport =
-                            this->hasExtension("GL_OES_standard_derivatives");
+        caps->fShaderDerivativeSupport = this->hasExtension("GL_OES_standard_derivatives");
     }
 
-    if (GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType()) {
+    if (GrGLCaps::kImaginationES_MSFBOType == this->glCaps().msFBOType()) {
+        GR_GL_GetIntegerv(this->glInterface(), GR_GL_MAX_SAMPLES_IMG, &caps->fMaxSampleCount);
+    } else if (GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType()) {
         GR_GL_GetIntegerv(this->glInterface(), GR_GL_MAX_SAMPLES, &caps->fMaxSampleCount);
     }
 }
 
 void GrGpuGL::fillInConfigRenderableTable() {
 
     // OpenGL < 3.0
     //  no support for render targets unless the GL_ARB_framebuffer_object
     //  extension is supported (in which case we get ALPHA, RED, RG, RGB,
     //  RGBA (ALPHA8, RGBA4, RGBA8) for OpenGL > 1.1). Note that we
@@ skipping 569 matching lines @@
     GrGLenum status;
 
     GrGLenum msColorFormat = 0; // suppress warning
 
     GL_CALL(GenFramebuffers(1, &desc->fTexFBOID));
     if (!desc->fTexFBOID) {
         goto FAILED;
     }
 
 
-    // If we are using multisampling we will create two FBOS. We render
-    // to one and then resolve to the texture bound to the other.
-    if (desc->fSampleCnt > 0) {
+    // If we are using multisampling we will create two FBOS. We render to one and then resolve to
+    // the texture bound to the other. The exception is the IMG multisample extension. With this
+    // extension the texture is multisampled when rendered to and then auto-resolves it when it is
+    // rendered from.
+    if (desc->fSampleCnt > 0 && GrGLCaps::kImaginationES_MSFBOType != this->glCaps().msFBOType()) {
         if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType()) {
             goto FAILED;
         }
         GL_CALL(GenFramebuffers(1, &desc->fRTFBOID));
         GL_CALL(GenRenderbuffers(1, &desc->fMSColorRenderbufferID));
         if (!desc->fRTFBOID ||
             !desc->fMSColorRenderbufferID ||
             !this->configToGLFormats(desc->fConfig,
                                      // GLES requires sized internal formats
                                      kES2_GrGLBinding == this->glBinding(),
@@ skipping 19 matching lines @@
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fRTFBOID));
         GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                       GR_GL_COLOR_ATTACHMENT0,
                                       GR_GL_RENDERBUFFER,
                                       desc->fMSColorRenderbufferID));
         if (!this->glCaps().isConfigVerifiedColorAttachment(desc->fConfig)) {
             GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
             if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
                 goto FAILED;
             }
-            fGLContext.info().caps().markConfigAsValidColorAttachment(
-                                                                desc->fConfig);
+            fGLContext.info().caps().markConfigAsValidColorAttachment(desc->fConfig);
         }
     }
     GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, desc->fTexFBOID));
 
-    GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
-                                 GR_GL_COLOR_ATTACHMENT0,
-                                 GR_GL_TEXTURE_2D,
-                                 texID, 0));
+    if (GrGLCaps::kImaginationES_MSFBOType == this->glCaps().msFBOType() && desc->fSampleCnt > 0) {
+        GL_CALL(FramebufferTexture2DMultisample(GR_GL_FRAMEBUFFER,
+                                                GR_GL_COLOR_ATTACHMENT0,
+                                                GR_GL_TEXTURE_2D,
+                                                texID, 0, desc->fSampleCnt));
+    } else {
+        GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
+                                     GR_GL_COLOR_ATTACHMENT0,
+                                     GR_GL_TEXTURE_2D,
+                                     texID, 0));
+    }
     if (!this->glCaps().isConfigVerifiedColorAttachment(desc->fConfig)) {
         GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
         if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
             goto FAILED;
         }
         fGLContext.info().caps().markConfigAsValidColorAttachment(desc->fConfig);
     }
 
     return true;
 
@@ skipping 221 matching lines @@
                 rt->setStencilBuffer(sb);
                 return true;
            }
            sb->abandon(); // otherwise we lose sbID
         }
     }
     GL_CALL(DeleteRenderbuffers(1, &sbID));
     return false;
 }
 
-bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb,
-                                                GrRenderTarget* rt) {
+bool GrGpuGL::attachStencilBufferToRenderTarget(GrStencilBuffer* sb, GrRenderTarget* rt) {
     GrGLRenderTarget* glrt = (GrGLRenderTarget*) rt;
 
     GrGLuint fbo = glrt->renderFBOID();
 
     if (NULL == sb) {
         if (NULL != rt->getStencilBuffer()) {
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_STENCIL_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
+                                            GR_GL_STENCIL_ATTACHMENT,
+                                            GR_GL_RENDERBUFFER, 0));
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
+                                            GR_GL_DEPTH_ATTACHMENT,
+                                            GR_GL_RENDERBUFFER, 0));
 #if GR_DEBUG
             GrGLenum status;
             GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
             GrAssert(GR_GL_FRAMEBUFFER_COMPLETE == status);
 #endif
         }
         return true;
     } else {
-        GrGLStencilBuffer* glsb = (GrGLStencilBuffer*) sb;
+        GrGLStencilBuffer* glsb = static_cast<GrGLStencilBuffer*>(sb);
         GrGLuint rb = glsb->renderbufferID();
 
         fHWBoundRenderTarget = NULL;
         GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, fbo));
         GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                      GR_GL_STENCIL_ATTACHMENT,
-                                      GR_GL_RENDERBUFFER, rb));
+                                        GR_GL_STENCIL_ATTACHMENT,
+                                        GR_GL_RENDERBUFFER, rb));
         if (glsb->format().fPacked) {
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, rb));
+                                            GR_GL_DEPTH_ATTACHMENT,
+                                            GR_GL_RENDERBUFFER, rb));
         } else {
             GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
-                                          GR_GL_DEPTH_ATTACHMENT,
-                                          GR_GL_RENDERBUFFER, 0));
+                                            GR_GL_DEPTH_ATTACHMENT,
+                                            GR_GL_RENDERBUFFER, 0));
         }
 
         GrGLenum status;
-        if (!this->glCaps().isColorConfigAndStencilFormatVerified(rt->config(),
-                                                           glsb->format())) {
+        if (!this->glCaps().isColorConfigAndStencilFormatVerified(rt->config(), glsb->format())) {
             GL_CALL_RET(status, CheckFramebufferStatus(GR_GL_FRAMEBUFFER));
             if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
                 GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                               GR_GL_STENCIL_ATTACHMENT,
                                               GR_GL_RENDERBUFFER, 0));
                 if (glsb->format().fPacked) {
                     GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER,
                                                   GR_GL_DEPTH_ATTACHMENT,
                                                   GR_GL_RENDERBUFFER, 0));
                 }
@@ skipping 532 matching lines @@
         default:
             // Only the above two fill rules are allowed.
             GrCrash("Unexpected path fill.");
             return; // suppress unused var warning.
     }
     GrGLint writeMask = fStencilSettings.writeMask(GrStencilSettings::kFront_Face);
     GL_CALL(StencilFillPath(id, fillMode, writeMask));
 }
 
 void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {
+    GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
+    if (rt->needsResolve()) {
+        // The IMG extension automatically resolves the texture when it is read.
+        if (GrGLCaps::kImaginationES_MSFBOType != this->glCaps().msFBOType()) {
+            GrAssert(GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType());
+            GrAssert(rt->textureFBOID() != rt->renderFBOID());
+            GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER, rt->renderFBOID()));
+            GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER, rt->textureFBOID()));
+            // make sure we go through flushRenderTarget() since we've modified
+            // the bound DRAW FBO ID.
+            fHWBoundRenderTarget = NULL;
+            const GrGLIRect& vp = rt->getViewport();
+            const GrIRect dirtyRect = rt->getResolveRect();
+            GrGLIRect r;
+            r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop,
+                            dirtyRect.width(), dirtyRect.height(), target->origin());
 
-    GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(target);
-
-    if (rt->needsResolve()) {
-        GrAssert(GrGLCaps::kNone_MSFBOType != this->glCaps().msFBOType());
-        GrAssert(rt->textureFBOID() != rt->renderFBOID());
-        GL_CALL(BindFramebuffer(GR_GL_READ_FRAMEBUFFER,
-                                rt->renderFBOID()));
-        GL_CALL(BindFramebuffer(GR_GL_DRAW_FRAMEBUFFER,
-                                rt->textureFBOID()));
-        // make sure we go through flushRenderTarget() since we've modified
-        // the bound DRAW FBO ID.
-        fHWBoundRenderTarget = NULL;
-        const GrGLIRect& vp = rt->getViewport();
-        const GrIRect dirtyRect = rt->getResolveRect();
-        GrGLIRect r;
-        r.setRelativeTo(vp, dirtyRect.fLeft, dirtyRect.fTop,
-                        dirtyRect.width(), dirtyRect.height(), target->origin());
-
-        GrAutoTRestore<ScissorState> asr;
-        if (GrGLCaps::kAppleES_MSFBOType == this->glCaps().msFBOType()) {
-            // Apple's extension uses the scissor as the blit bounds.
-            asr.reset(&fScissorState);
-            fScissorState.fEnabled = true;
-            fScissorState.fRect = dirtyRect;
-            this->flushScissor();
-            GL_CALL(ResolveMultisampleFramebuffer());
-        } else {
-            if (GrGLCaps::kDesktopARB_MSFBOType != this->glCaps().msFBOType()) {
-                // this respects the scissor during the blit, so disable it.
-                GrAssert(GrGLCaps::kDesktopEXT_MSFBOType ==
-                         this->glCaps().msFBOType());
+            GrAutoTRestore<ScissorState> asr;
+            if (GrGLCaps::kAppleES_MSFBOType == this->glCaps().msFBOType()) {
+                // Apple's extension uses the scissor as the blit bounds.
                 asr.reset(&fScissorState);
-                fScissorState.fEnabled = false;
+                fScissorState.fEnabled = true;
+                fScissorState.fRect = dirtyRect;
                 this->flushScissor();
+                GL_CALL(ResolveMultisampleFramebuffer());
+            } else {
+                if (GrGLCaps::kDesktopARB_MSFBOType != this->glCaps().msFBOType()) {
+                    // this respects the scissor during the blit, so disable it.
+                    GrAssert(GrGLCaps::kDesktopEXT_MSFBOType == this->glCaps().msFBOType());
+                    asr.reset(&fScissorState);
+                    fScissorState.fEnabled = false;
+                    this->flushScissor();
+                }
+                int right = r.fLeft + r.fWidth;
+                int top = r.fBottom + r.fHeight;
+                GL_CALL(BlitFramebuffer(r.fLeft, r.fBottom, right, top,
+                                        r.fLeft, r.fBottom, right, top,
+                                        GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST));
             }
-            int right = r.fLeft + r.fWidth;
-            int top = r.fBottom + r.fHeight;
-            GL_CALL(BlitFramebuffer(r.fLeft, r.fBottom, right, top,
-                                    r.fLeft, r.fBottom, right, top,
-                                    GR_GL_COLOR_BUFFER_BIT, GR_GL_NEAREST));
         }
         rt->flagAsResolved();
     }
 }
 
 namespace {
 
 GrGLenum gr_to_gl_stencil_func(GrStencilFunc basicFunc) {
     static const GrGLenum gTable[] = {
         GR_GL_ALWAYS,           // kAlways_StencilFunc
@@ skipping 521 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }