Dynamically create stencil buffer when needed.

src/gpu/GrGpu.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
 
 #include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpuResourcePriv.h"
 #include "GrIndexBuffer.h"
 #include "GrResourceCache.h"
+#include "GrRenderTargetPriv.h"
 #include "GrStencilBuffer.h"
 #include "GrVertexBuffer.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGpu::GrGpu(GrContext* context)
     : fResetTimestamp(kExpiredTimestamp+1)
     , fResetBits(kAll_GrBackendState)
     , fQuadIndexBuffer(NULL)
     , fContext(context) {
@@ skipping 26 matching lines @@
         if (!this->caps()->npotTextureTileSupport() &&
             (!SkIsPow2(desc.fWidth) || !SkIsPow2(desc.fHeight))) {
             return NULL;
         }
 
         this->handleDirtyContext();
         tex = this->onCreateCompressedTexture(desc, budgeted, srcData);
     } else {
         this->handleDirtyContext();
         tex = this->onCreateTexture(desc, budgeted, srcData, rowBytes);
-        if (tex &&
-            (kRenderTarget_GrSurfaceFlag & desc.fFlags) &&
-            !(kNoStencil_GrSurfaceFlag & desc.fFlags)) {
-            SkASSERT(tex->asRenderTarget());
-            // TODO: defer this and attach dynamically
-            if (!this->attachStencilBufferToRenderTarget(tex->asRenderTarget())) {
-                tex->unref();
-                return NULL;
-            }
-        }
     }
     if (!this->caps()->reuseScratchTextures() && !isRT) {
         tex->resourcePriv().removeScratchKey();
     }
     if (tex) {
         fStats.incTextureCreates();
         if (srcData) {
             fStats.incTextureUploads();
         }
     }
     return tex;
 }
 
 bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) {
-    SkASSERT(NULL == rt->getStencilBuffer());
+    SkASSERT(NULL == rt->renderTargetPriv().getStencilBuffer());
     GrUniqueKey sbKey;
 
     int width = rt->width();
     int height = rt->height();
     if (this->caps()->oversizedStencilSupport()) {
         width  = SkNextPow2(width);
         height = SkNextPow2(height);
     }
 
     GrStencilBuffer::ComputeSharedStencilBufferKey(width, height, rt->numSamples(), &sbKey);
     SkAutoTUnref<GrStencilBuffer> sb(static_cast<GrStencilBuffer*>(
         this->getContext()->getResourceCache()->findAndRefUniqueResource(sbKey)));
     if (sb) {
-        rt->setStencilBuffer(sb);
-        bool attached = this->attachStencilBufferToRenderTarget(sb, rt);
-        if (!attached) {
-            rt->setStencilBuffer(NULL);
+        if (this->attachStencilBufferToRenderTarget(sb, rt)) {
+            rt->renderTargetPriv().didAttachStencilBuffer(sb);
+            return true;
         }
-        return attached;
+        return false;
     }
     if (this->createStencilBufferForRenderTarget(rt, width, height)) {
         // Right now we're clearing the stencil buffer here after it is
         // attached to an RT for the first time. When we start matching
         // stencil buffers with smaller color targets this will no longer
         // be correct because it won't be guaranteed to clear the entire
         // sb.
         // We used to clear down in the GL subclass using a special purpose
         // FBO. But iOS doesn't allow a stencil-only FBO. It reports unsupported
         // FBO status.
         this->clearStencil(rt);
-        rt->getStencilBuffer()->resourcePriv().setUniqueKey(sbKey);
+        GrStencilBuffer* sb = rt->renderTargetPriv().getStencilBuffer();
+        sb->resourcePriv().setUniqueKey(sbKey);
         return true;
     } else {
         return false;
     }
 }
 
 GrTexture* GrGpu::wrapBackendTexture(const GrBackendTextureDesc& desc) {
     this->handleDirtyContext();
     GrTexture* tex = this->onWrapBackendTexture(desc);
     if (NULL == tex) {
@@ skipping 191 matching lines @@
                       GrDrawTarget::PathIndexType indexType,
                       const float transformValues[],
                       GrDrawTarget::PathTransformType transformType,
                       int count,
                       const GrStencilSettings& stencilSettings) {
     this->handleDirtyContext();
     pathRange->willDrawPaths(indices, indexType, count);
     this->onDrawPaths(args, pathRange, indices, indexType, transformValues,
                       transformType, count, stencilSettings);
 }