Track nested picture xform state for layer hoisting

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 "GrRecordReplaceDraw.h"
 
 #include "SkCanvas.h"
 #include "SkGrPixelRef.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const GrAccelData::SaveLayerInfo& info,
                                  const SkIRect& layerRect,
                                  SkTDArray<GrHoistedLayer>* atlased,
                                  SkTDArray<GrHoistedLayer>* nonAtlased,
                                  SkTDArray<GrHoistedLayer>* recycled) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
+    SkMatrix combined = SkMatrix::Concat(info.fPreMat, info.fLocalMat);
+
     GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(),
                                                          info.fSaveLayerOpID,
                                                          info.fRestoreOpID,
                                                          layerRect,
-                                                         info.fOriginXform,
+                                                         combined,
                                                          info.fPaint);
-
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit;
     desc.fWidth = layerRect.width();
     desc.fHeight = layerRect.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
     // TODO: need to deal with sample count
 
 
     bool disallowAtlasing = info.fHasNestedLayers || info.fIsNested ||
                             (layer->paint() && layer->paint()->getImageFilter());
@@ skipping 13 matching lines @@
             hl = nonAtlased->append();
         }
     } else {
         hl = recycled->append();
     }
     
     layerCache->addUse(layer);
     hl->fLayer = layer;
     hl->fPicture = pict;
     hl->fOffset = SkIPoint::Make(layerRect.fLeft, layerRect.fTop);
-    hl->fCTM = info.fOriginXform;
+    hl->fLocalMat = info.fLocalMat;
+    hl->fPreMat = info.fPreMat;
 }
 
 // Return true if any layers are suitable for hoisting
 bool GrLayerHoister::FindLayersToHoist(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* atlased,
                                        SkTDArray<GrHoistedLayer>* nonAtlased,
                                        SkTDArray<GrHoistedLayer>* recycled) {
     GrLayerCache* layerCache = context->getLayerCache();
@@ skipping 27 matching lines @@
     // Find and prepare for hoisting all the layers that intersect the query rect
     for (int i = 0; i < topLevelGPUData->numSaveLayers(); ++i) {
 
         const GrAccelData::SaveLayerInfo& info = topLevelGPUData->saveLayerInfo(i);
 
         SkRect layerRect = SkRect::Make(info.fBounds);
         if (!layerRect.intersect(query)) {
             continue;
         }
 
-
         SkIRect ir;
         layerRect.roundOut(&ir);
 
         // 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.fIsNested) {
             continue;
         }
 
@@ skipping 10 matching lines @@
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 static void convert_layers_to_replacements(const SkTDArray<GrHoistedLayer>& layers,
                                            GrReplacements* replacements) {
     // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer?
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
         const SkPicture* picture = layers[i].fPicture;
 
+        SkMatrix combined = SkMatrix::Concat(layers[i].fPreMat, layers[i].fLocalMat);
+
         GrReplacements::ReplacementInfo* layerInfo =
                     replacements->newReplacement(picture->uniqueID(),
                                                  layer->start(),
-                                                 layers[i].fCTM);
+                                                 combined);
         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);
 
         layerInfo->fPaint = layers[i].fLayer->paint()
                                 ? SkNEW_ARGS(SkPaint, (*layers[i].fLayer->paint()))
                                 : NULL;
 
         layerInfo->fSrcRect = SkIRect::MakeXYWH(layers[i].fLayer->rect().fLeft,
                                                 layers[i].fLayer->rect().fTop,
                                                 layers[i].fLayer->rect().width(),
                                                 layers[i].fLayer->rect().height());
     }
 }
 
-void GrLayerHoister::DrawLayers(const SkTDArray<GrHoistedLayer>& atlased,
+void GrLayerHoister::DrawLayers(GrContext* context,
+                                const SkTDArray<GrHoistedLayer>& atlased,
                                 const SkTDArray<GrHoistedLayer>& nonAtlased,
                                 const SkTDArray<GrHoistedLayer>& recycled,
                                 GrReplacements* replacements) {
     // Render the atlased layers that require it
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         atlased[0].fLayer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
-        SkPaint paint;
-        paint.setColor(SK_ColorTRANSPARENT);
-        paint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref();
+        SkPaint clearPaint;
+        clearPaint.setColor(SK_ColorTRANSPARENT);
+        clearPaint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref();
 
         for (int i = 0; i < atlased.count(); ++i) {
-            GrCachedLayer* layer = atlased[i].fLayer;
+            const GrCachedLayer* layer = atlased[i].fLayer;
             const SkPicture* pict = atlased[i].fPicture;
             const SkIPoint offset = atlased[i].fOffset;
+            SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();)
+
+            SkASSERT(!layerPaint || !layerPaint->getImageFilter());
 
             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);
+            atlasCanvas->drawRect(bound, clearPaint);
 
             // 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(-offset.fX), 
                                     SkIntToScalar(-offset.fY));
             initialCTM.postTranslate(bound.fLeft, bound.fTop);
-            
+            initialCTM.postConcat(atlased[i].fPreMat);
+
             atlasCanvas->translate(SkIntToScalar(-offset.fX), 
                                    SkIntToScalar(-offset.fY));
             atlasCanvas->translate(bound.fLeft, bound.fTop);
-            atlasCanvas->concat(atlased[i].fCTM);
+            atlasCanvas->concat(atlased[i].fPreMat);
+            atlasCanvas->concat(atlased[i].fLocalMat);
 
             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;
+        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();
 
+        SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
+
         // 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(-offset.fX), 
-                                SkIntToScalar(-offset.fY));
+        initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
+        initialCTM.postConcat(nonAtlased[i].fPreMat);
 
-        layerCanvas->translate(SkIntToScalar(-offset.fX), 
-                               SkIntToScalar(-offset.fY));
-        layerCanvas->concat(nonAtlased[i].fCTM);
+        layerCanvas->translate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
+        layerCanvas->concat(nonAtlased[i].fPreMat);
+        layerCanvas->concat(nonAtlased[i].fLocalMat);
 
         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);
     convert_layers_to_replacements(recycled, replacements);
@@ skipping 20 matching lines @@
 #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
 
     SkDEBUGCODE(layerCache->validate();)
 }