Texturing support for RECTANGLE textures.

src/gpu/GrTextureParamsAdjuster.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureParamsAdjuster.h"
 
 #include "GrCaps.h"
@@ skipping 115 matching lines @@
                                      bool isAlphaOnly)
     : INHERITED(contentArea.width(), contentArea.height(), isAlphaOnly)
     , fOriginal(original) {
     SkASSERT(SkIRect::MakeWH(original->width(), original->height()).contains(contentArea));
     if (contentArea.fLeft > 0 || contentArea.fTop > 0 ||
         contentArea.fRight < original->width() || contentArea.fBottom < original->height()) {
         fContentArea.set(contentArea);
     }
 }
 
+GrTexture* GrTextureAdjuster::refCopy(const CopyParams& copyParams) {
+    GrTexture* texture = this->originalTexture();
+    GrContext* context = texture->getContext();
+    const SkIRect* contentArea = this->contentAreaOrNull();
+    GrUniqueKey key;
+    this->makeCopyKey(copyParams, &key);
+    if (key.isValid()) {
+        GrTexture* cachedCopy = context->textureProvider()->findAndRefTextureByUniqueKey(key);
+        if (cachedCopy) {
+            return cachedCopy;
+        }
+    }
+    GrTexture* copy = copy_on_gpu(texture, contentArea, copyParams);
+    if (copy) {
+        if (key.isValid()) {
+            copy->resourcePriv().setUniqueKey(key);
+            this->didCacheCopy(key);
+        }
+    }
+    return copy;
+}
+
 GrTexture* GrTextureAdjuster::refTextureSafeForParams(const GrTextureParams& params,
                                                       SkIPoint* outOffset) {
     GrTexture* texture = this->originalTexture();
     GrContext* context = texture->getContext();
     CopyParams copyParams;
     const SkIRect* contentArea = this->contentAreaOrNull();
 
     if (contentArea && GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
         // If we generate a MIP chain for texture it will read pixel values from outside the content
         // area.
         copyParams.fWidth = contentArea->width();
         copyParams.fHeight = contentArea->height();
         copyParams.fFilter = GrTextureParams::kBilerp_FilterMode;
-    } else if (!context->getGpu()->makeCopyForTextureParams(texture->width(), texture->height(),
-                                                            params, &copyParams)) {
+    } else if (!context->getGpu()->makeCopyForTextureParams(texture, params, &copyParams)) {
         if (outOffset) {
             if (contentArea) {
                 outOffset->set(contentArea->fLeft, contentArea->fRight);
             } else {
                 outOffset->set(0, 0);
             }
         }
         return SkRef(texture);
     }
-    GrUniqueKey key;
-    this->makeCopyKey(copyParams, &key);
-    if (key.isValid()) {
-        GrTexture* result = context->textureProvider()->findAndRefTextureByUniqueKey(key);
-        if (result) {
-            return result;
-        }
+
+    GrTexture* copy = this->refCopy(copyParams);
+    if (copy && outOffset) {
+        outOffset->set(0, 0);
     }
-    GrTexture* result = copy_on_gpu(texture, contentArea, copyParams);
-    if (result) {
-        if (key.isValid()) {
-            result->resourcePriv().setUniqueKey(key);
-            this->didCacheCopy(key);
-        }
-        if (outOffset) {
-            outOffset->set(0, 0);
-        }
-    }
-    return result;
+    return copy;
 }
 
 enum DomainMode {
     kNoDomain_DomainMode,
     kDomain_DomainMode,
     kTightCopy_DomainMode
 };
 
 /** Determines whether a texture domain is necessary and if so what domain to use. There are two
  *  rectangles to consider:
@@ skipping 156 matching lines @@
                                                  *filterOrNullForBicubic);
         } else {
             GrTextureParams params(SkShader::kClamp_TileMode, *filterOrNullForBicubic);
             return GrSimpleTextureEffect::Create(texture, textureMatrix, params);
         }
     } else {
         if (kDomain_DomainMode == domainMode) {
             return GrBicubicEffect::Create(texture, textureMatrix, domain);
         } else {
             static const SkShader::TileMode kClampClamp[] =
-            { SkShader::kClamp_TileMode, SkShader::kClamp_TileMode };
+                { SkShader::kClamp_TileMode, SkShader::kClamp_TileMode };
             return GrBicubicEffect::Create(texture, textureMatrix, kClampClamp);
         }
     }
 }
 
 const GrFragmentProcessor* GrTextureAdjuster::createFragmentProcessor(
                                         const SkMatrix& origTextureMatrix,
                                         const SkRect& origConstraintRect,
                                         FilterConstraint filterConstraint,
                                         bool coordsLimitedToConstraintRect,
                                         const GrTextureParams::FilterMode* filterOrNullForBicubic) {
 
     SkMatrix textureMatrix = origTextureMatrix;
     const SkIRect* contentArea = this->contentAreaOrNull();
     // Convert the constraintRect to be relative to the texture rather than the content area so
     // that both rects are in the same coordinate system.
     SkTCopyOnFirstWrite<SkRect> constraintRect(origConstraintRect);
     if (contentArea) {
         SkScalar l = SkIntToScalar(contentArea->fLeft);
         SkScalar t = SkIntToScalar(contentArea->fTop);
         constraintRect.writable()->offset(l, t);
         textureMatrix.postTranslate(l, t);
     }
 
     SkRect domain;
-    GrTexture* texture = this->originalTexture();
+    GrTextureParams params;
+    if (filterOrNullForBicubic) {
+        params.setFilterMode(*filterOrNullForBicubic);
+    }
+    SkAutoTUnref<GrTexture> texture(this->refTextureSafeForParams(params, nullptr));
+    if (!texture) {
+        return nullptr;
+    }
+    // If we made a copy then we only copied the contentArea, in which case the new texture is all
+    // content.
+    if (texture != this->originalTexture()) {
+        contentArea = nullptr;
+    }
+
     DomainMode domainMode =
         determine_domain_mode(*constraintRect, filterConstraint, coordsLimitedToConstraintRect,
                               texture->width(), texture->height(),
                               contentArea, filterOrNullForBicubic,
                               &domain);
     if (kTightCopy_DomainMode == domainMode) {
         // TODO: Copy the texture and adjust the texture matrix (both parts need to consider
         // non-int constraint rect)
         // For now: treat as bilerp and ignore what goes on above level 0.
 
@@ skipping 85 matching lines @@
                                            filterOrNullForBicubic);
 }
 
 GrTexture* GrTextureMaker::generateTextureForParams(const CopyParams& copyParams) {
     SkAutoTUnref<GrTexture> original(this->refOriginalTexture());
     if (!original) {
         return nullptr;
     }
     return copy_on_gpu(original, nullptr, copyParams);
 }