Move offset and CTM from LayerCache Key to per-hoisted-layer info

src/gpu/GrLayerHoister.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "SkCanvas.h"
@@ skipping 38 matching lines @@
 
         SkRect layerRect = SkRect::MakeXYWH(SkIntToScalar(info.fOffset.fX),
                                             SkIntToScalar(info.fOffset.fY),
                                             SkIntToScalar(info.fSize.fWidth),
                                             SkIntToScalar(info.fSize.fHeight));
 
         if (!SkRect::Intersects(query, layerRect)) {
             continue;
         }
 
+        // TODO: ignore perspective projected layers here!
         // TODO: once this code is more stable unsuitable layers can
         // just be omitted during the optimization stage
         if (!info.fValid ||
             kSaveLayerMaxSize < info.fSize.fWidth ||
             kSaveLayerMaxSize < info.fSize.fHeight ||
             info.fIsNested) {
             continue;
         }
 
         pullForward[i] = true;
         anyHoisted = true;
     }
 
     if (!anyHoisted) {
         return false;
     }
 
     atlased->setReserve(atlased->reserved() + topLevelGPUData->numSaveLayers());
 
     // Generate the layer and/or ensure it is locked
     for (int i = 0; i < topLevelGPUData->numSaveLayers(); ++i) {
         if (pullForward[i]) {
             const GrAccelData::SaveLayerInfo& info = topLevelGPUData->saveLayerInfo(i);
             const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
             GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(),
                                                                  info.fSaveLayerOpID,
                                                                  info.fRestoreOpID,
-                                                                 info.fOffset,
                                                                  info.fOriginXform,
                                                                  info.fPaint);
 
             GrTextureDesc desc;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = info.fSize.fWidth;
             desc.fHeight = info.fSize.fHeight;
             desc.fConfig = kSkia8888_GrPixelConfig;
             // TODO: need to deal with sample count
 
             bool needsRendering = layerCache->lock(layer, desc,
                                                    info.fHasNestedLayers || info.fIsNested);
             if (NULL == layer->texture()) {
                 continue;
             }
 
             if (needsRendering) {
-                HoistedLayer* info;
+                HoistedLayer* hl;
 
                 if (layer->isAtlased()) {
-                    info = atlased->append();
+                    hl = atlased->append();
                 } else {
-                    info = nonAtlased->append();
+                    hl = nonAtlased->append();
                 }
 
-                info->fLayer = layer;
-                info->fPicture = pict;
+                hl->fLayer = layer;
+                hl->fPicture = pict;
+                hl->fOffset = info.fOffset;
+                hl->fCTM = info.fOriginXform;
             }
         }
     }
 
     return anyHoisted;
 }
 
 static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 static void convert_layers_to_replacements(const SkTDArray<GrLayerHoister::HoistedLayer>& layers,
                                            GrReplacements* replacements) {
     // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer?
     for (int i = 0; i < layers.count(); ++i) {
+        GrCachedLayer* layer = layers[i].fLayer;
+
         GrReplacements::ReplacementInfo* layerInfo = replacements->push();
-        layerInfo->fStart = layers[i].fLayer->start();
-        layerInfo->fStop = layers[i].fLayer->stop();
-        layerInfo->fPos = layers[i].fLayer->offset();;
+        layerInfo->fStart = layer->start();
+        layerInfo->fStop = layer->stop();
+        layerInfo->fPos = layers[i].fOffset;
 
         SkBitmap bm;
         wrap_texture(layers[i].fLayer->texture(),
                      !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().width()
                                                     : layers[i].fLayer->texture()->width(),
                      !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().height()
                                                     : layers[i].fLayer->texture()->height(),
                      &bm);
         layerInfo->fImage = SkImage::NewTexture(bm);
 
@@ skipping 19 matching lines @@
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
         SkPaint paint;
         paint.setColor(SK_ColorTRANSPARENT);
         paint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref();
 
         for (int i = 0; i < atlased.count(); ++i) {
             GrCachedLayer* layer = atlased[i].fLayer;
             const SkPicture* pict = atlased[i].fPicture;
+            const SkIPoint offset = atlased[i].fOffset;
 
             atlasCanvas->save();
 
             // Add a rect clip to make sure the rendering doesn't
             // extend beyond the boundaries of the atlased sub-rect
             SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft),
                                             SkIntToScalar(layer->rect().fTop),
                                             SkIntToScalar(layer->rect().width()),
                                             SkIntToScalar(layer->rect().height()));
             atlasCanvas->clipRect(bound);
 
             // Since 'clear' doesn't respect the clip we need to draw a rect
             // TODO: ensure none of the atlased layers contain a clear call!
             atlasCanvas->drawRect(bound, paint);
 
             // info.fCTM maps the layer's top/left to the origin.
             // Since this layer is atlased, the top/left corner needs
             // to be offset to the correct location in the backing texture.
             SkMatrix initialCTM;
-            initialCTM.setTranslate(SkIntToScalar(-layer->offset().fX), 
-                                    SkIntToScalar(-layer->offset().fY));
+            initialCTM.setTranslate(SkIntToScalar(-offset.fX), 
+                                    SkIntToScalar(-offset.fY));
             initialCTM.postTranslate(bound.fLeft, bound.fTop);
             
-            atlasCanvas->translate(SkIntToScalar(-layer->offset().fX), 
-                                   SkIntToScalar(-layer->offset().fY));
+            atlasCanvas->translate(SkIntToScalar(-offset.fX), 
+                                   SkIntToScalar(-offset.fY));
             atlasCanvas->translate(bound.fLeft, bound.fTop);
-            atlasCanvas->concat(layer->ctm());
+            atlasCanvas->concat(atlased[i].fCTM);
 
             SkRecordPartialDraw(*pict->fRecord.get(), atlasCanvas, bound,
                                 layer->start()+1, layer->stop(), initialCTM);
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 
     // Render the non-atlased layers that require it
     for (int i = 0; i < nonAtlased.count(); ++i) {
         GrCachedLayer* layer = nonAtlased[i].fLayer;
         const SkPicture* pict = nonAtlased[i].fPicture;
+        const SkIPoint offset = nonAtlased[i].fOffset;
 
         // Each non-atlased layer has its own GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         layer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* layerCanvas = surface->getCanvas();
 
         // Add a rect clip to make sure the rendering doesn't
         // extend beyond the boundaries of the atlased sub-rect
         SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft),
                                         SkIntToScalar(layer->rect().fTop),
                                         SkIntToScalar(layer->rect().width()),
                                         SkIntToScalar(layer->rect().height()));
 
         layerCanvas->clipRect(bound); // TODO: still useful?
 
         layerCanvas->clear(SK_ColorTRANSPARENT);
 
         SkMatrix initialCTM;
-        initialCTM.setTranslate(SkIntToScalar(-layer->offset().fX), 
-                                SkIntToScalar(-layer->offset().fY));
+        initialCTM.setTranslate(SkIntToScalar(-offset.fX), 
+                                SkIntToScalar(-offset.fY));
 
-        layerCanvas->translate(SkIntToScalar(-layer->offset().fX), 
-                               SkIntToScalar(-layer->offset().fY));
-        layerCanvas->concat(layer->ctm());
+        layerCanvas->translate(SkIntToScalar(-offset.fX), 
+                               SkIntToScalar(-offset.fY));
+        layerCanvas->concat(nonAtlased[i].fCTM);
 
         SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas, bound,
                             layer->start()+1, layer->stop(), initialCTM);
 
         layerCanvas->flush();
     }
 
     convert_layers_to_replacements(atlased, replacements);
     convert_layers_to_replacements(nonAtlased, replacements);
 }
 
 static void unlock_layer_in_cache(GrLayerCache* layerCache,
                                   const SkPicture* picture,
                                   GrCachedLayer* layer) {
     layerCache->unlock(layer);
 
 #if DISABLE_CACHING
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purge(picture->uniqueID());
 #endif
 }
 
-void GrLayerHoister::UnlockLayers(GrLayerCache* layerCache, 
+void GrLayerHoister::UnlockLayers(GrLayerCache* layerCache,
                                   const SkTDArray<HoistedLayer>& atlased,
                                   const SkTDArray<HoistedLayer>& nonAtlased) {
 
     for (int i = 0; i < atlased.count(); ++i) {
         unlock_layer_in_cache(layerCache, atlased[i].fPicture, atlased[i].fLayer);
     }
 
     for (int i = 0; i < nonAtlased.count(); ++i) {
         unlock_layer_in_cache(layerCache, nonAtlased[i].fPicture, nonAtlased[i].fLayer);
     }
 
 #if DISABLE_CACHING
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 }