robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "GrLayerCache.h" |
| 9 | #include "GrLayerHoister.h" |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 10 | #include "GrRecordReplaceDraw.h" |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 11 | |
| 12 | #include "SkCanvas.h" |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 13 | #include "SkGrPixelRef.h" |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 14 | #include "SkLayerInfo.h" |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 15 | #include "SkRecordDraw.h" |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 16 | #include "SkSurface.h" |
| 17 | |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 18 | // Create the layer information for the hoisted layer and secure the |
| 19 | // required texture/render target resources. |
| 20 | static void prepare_for_hoisting(GrLayerCache* layerCache, |
robertphillips | 232f6b0 | 2014-10-09 16:43:42 -0700 | [diff] [blame] | 21 | const SkPicture* topLevelPicture, |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 22 | const SkLayerInfo::BlockInfo& info, |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 23 | const SkIRect& layerRect, |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 24 | SkTDArray<GrHoistedLayer>* needRendering, |
| 25 | SkTDArray<GrHoistedLayer>* recycled, |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 26 | bool attemptToAtlas, |
| 27 | int numSamples) { |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 28 | const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture; |
| 29 | |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 30 | SkMatrix combined = SkMatrix::Concat(info.fPreMat, info.fLocalMat); |
| 31 | |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 32 | GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(), |
| 33 | info.fSaveLayerOpID, |
| 34 | info.fRestoreOpID, |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 35 | layerRect, |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 36 | combined, |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 37 | info.fPaint); |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 38 | GrSurfaceDesc desc; |
| 39 | desc.fFlags = kRenderTarget_GrSurfaceFlag; |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 40 | desc.fWidth = layerRect.width(); |
| 41 | desc.fHeight = layerRect.height(); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 42 | desc.fConfig = kSkia8888_GrPixelConfig; |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 43 | desc.fSampleCnt = numSamples; |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 44 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 45 | bool locked, needsRendering; |
| 46 | if (attemptToAtlas) { |
| 47 | locked = layerCache->tryToAtlas(layer, desc, &needsRendering); |
| 48 | } else { |
| 49 | locked = layerCache->lock(layer, desc, &needsRendering); |
| 50 | } |
| 51 | if (!locked) { |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 52 | // GPU resources could not be secured for the hoisting of this layer |
| 53 | return; |
| 54 | } |
| 55 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 56 | if (attemptToAtlas) { |
| 57 | SkASSERT(layer->isAtlased()); |
| 58 | } |
| 59 | |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 60 | GrHoistedLayer* hl; |
| 61 | |
| 62 | if (needsRendering) { |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 63 | if (!attemptToAtlas) { |
| 64 | SkASSERT(!layer->isAtlased()); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 65 | } |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 66 | hl = needRendering->append(); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 67 | } else { |
| 68 | hl = recycled->append(); |
| 69 | } |
| 70 | |
robertphillips | 7bb9ed7 | 2014-10-10 11:38:29 -0700 | [diff] [blame] | 71 | layerCache->addUse(layer); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 72 | hl->fLayer = layer; |
| 73 | hl->fPicture = pict; |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 74 | hl->fOffset = SkIPoint::Make(layerRect.fLeft, layerRect.fTop); |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 75 | hl->fLocalMat = info.fLocalMat; |
| 76 | hl->fPreMat = info.fPreMat; |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 77 | } |
| 78 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 79 | // Atlased layers must be small enough to fit in the atlas, not have a |
| 80 | // paint with an image filter and be neither nested nor nesting. |
| 81 | // TODO: allow leaf nested layers to appear in the atlas. |
| 82 | void GrLayerHoister::FindLayersToAtlas(GrContext* context, |
robertphillips | d61ef01 | 2014-10-08 05:17:02 -0700 | [diff] [blame] | 83 | const SkPicture* topLevelPicture, |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 84 | const SkRect& query, |
robertphillips | d61ef01 | 2014-10-08 05:17:02 -0700 | [diff] [blame] | 85 | SkTDArray<GrHoistedLayer>* atlased, |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 86 | SkTDArray<GrHoistedLayer>* recycled, |
| 87 | int numSamples) { |
| 88 | if (0 != numSamples) { |
| 89 | // MSAA layers are currently never atlased |
| 90 | return; |
| 91 | } |
| 92 | |
robertphillips | d61ef01 | 2014-10-08 05:17:02 -0700 | [diff] [blame] | 93 | GrLayerCache* layerCache = context->getLayerCache(); |
| 94 | |
| 95 | layerCache->processDeletedPictures(); |
| 96 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 97 | SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey(); |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 98 | |
| 99 | const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 100 | if (!topLevelData) { |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 101 | return; |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 102 | } |
| 103 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 104 | const SkLayerInfo *topLevelGPUData = static_cast<const SkLayerInfo*>(topLevelData); |
| 105 | if (0 == topLevelGPUData->numBlocks()) { |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 106 | return; |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 107 | } |
| 108 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 109 | atlased->setReserve(atlased->count() + topLevelGPUData->numBlocks()); |
robertphillips | cbe80ca | 2014-10-09 15:36:06 -0700 | [diff] [blame] | 110 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 111 | for (int i = 0; i < topLevelGPUData->numBlocks(); ++i) { |
| 112 | const SkLayerInfo::BlockInfo& info = topLevelGPUData->block(i); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 113 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 114 | // TODO: ignore perspective projected layers here? |
| 115 | bool disallowAtlasing = info.fHasNestedLayers || info.fIsNested || |
| 116 | (info.fPaint && info.fPaint->getImageFilter()); |
| 117 | |
| 118 | if (disallowAtlasing) { |
| 119 | continue; |
| 120 | } |
| 121 | |
robertphillips | d8aa7b7 | 2014-10-30 16:45:02 -0700 | [diff] [blame] | 122 | SkRect layerRect = info.fBounds; |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 123 | if (!layerRect.intersect(query)) { |
robertphillips | 2ed8a75 | 2014-09-03 13:46:02 -0700 | [diff] [blame] | 124 | continue; |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 125 | } |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 126 | |
robertphillips | 3aac6e0 | 2014-10-20 08:52:40 -0700 | [diff] [blame] | 127 | SkIRect ir; |
| 128 | layerRect.roundOut(&ir); |
| 129 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 130 | if (!GrLayerCache::PlausiblyAtlasable(ir.width(), ir.height())) { |
robertphillips | 2ed8a75 | 2014-09-03 13:46:02 -0700 | [diff] [blame] | 131 | continue; |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 132 | } |
robertphillips | 2ed8a75 | 2014-09-03 13:46:02 -0700 | [diff] [blame] | 133 | |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 134 | prepare_for_hoisting(layerCache, topLevelPicture, info, ir, atlased, recycled, true, 0); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 135 | } |
| 136 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | void GrLayerHoister::FindLayersToHoist(GrContext* context, |
| 140 | const SkPicture* topLevelPicture, |
| 141 | const SkRect& query, |
| 142 | SkTDArray<GrHoistedLayer>* needRendering, |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 143 | SkTDArray<GrHoistedLayer>* recycled, |
| 144 | int numSamples) { |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 145 | GrLayerCache* layerCache = context->getLayerCache(); |
| 146 | |
| 147 | layerCache->processDeletedPictures(); |
| 148 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 149 | SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey(); |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 150 | |
| 151 | const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key); |
| 152 | if (!topLevelData) { |
| 153 | return; |
| 154 | } |
| 155 | |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 156 | const SkLayerInfo *topLevelGPUData = static_cast<const SkLayerInfo*>(topLevelData); |
| 157 | if (0 == topLevelGPUData->numBlocks()) { |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 158 | return; |
| 159 | } |
| 160 | |
| 161 | // Find and prepare for hoisting all the layers that intersect the query rect |
robertphillips | 8236591 | 2014-11-12 09:32:34 -0800 | [diff] [blame] | 162 | for (int i = 0; i < topLevelGPUData->numBlocks(); ++i) { |
| 163 | const SkLayerInfo::BlockInfo& info = topLevelGPUData->block(i); |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 164 | if (info.fIsNested) { |
| 165 | // Parent layers are currently hoisted while nested layers are not. |
| 166 | continue; |
| 167 | } |
| 168 | |
robertphillips | d8aa7b7 | 2014-10-30 16:45:02 -0700 | [diff] [blame] | 169 | SkRect layerRect = info.fBounds; |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 170 | if (!layerRect.intersect(query)) { |
| 171 | continue; |
| 172 | } |
| 173 | |
| 174 | SkIRect ir; |
| 175 | layerRect.roundOut(&ir); |
| 176 | |
| 177 | prepare_for_hoisting(layerCache, topLevelPicture, info, ir, |
robertphillips | a63f32e | 2014-11-10 08:10:42 -0800 | [diff] [blame] | 178 | needRendering, recycled, false, numSamples); |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 179 | } |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 180 | } |
| 181 | |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 182 | static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) { |
| 183 | SkImageInfo info = SkImageInfo::MakeN32Premul(width, height); |
| 184 | result->setInfo(info); |
| 185 | result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref(); |
| 186 | } |
| 187 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 188 | void GrLayerHoister::ConvertLayersToReplacements(const SkTDArray<GrHoistedLayer>& layers, |
| 189 | GrReplacements* replacements) { |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 190 | // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer? |
| 191 | for (int i = 0; i < layers.count(); ++i) { |
robertphillips | ed42059 | 2014-09-29 11:39:38 -0700 | [diff] [blame] | 192 | GrCachedLayer* layer = layers[i].fLayer; |
robertphillips | 68cd2aa | 2014-10-01 09:24:06 -0700 | [diff] [blame] | 193 | const SkPicture* picture = layers[i].fPicture; |
robertphillips | ed42059 | 2014-09-29 11:39:38 -0700 | [diff] [blame] | 194 | |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 195 | SkMatrix combined = SkMatrix::Concat(layers[i].fPreMat, layers[i].fLocalMat); |
| 196 | |
robertphillips | 68cd2aa | 2014-10-01 09:24:06 -0700 | [diff] [blame] | 197 | GrReplacements::ReplacementInfo* layerInfo = |
| 198 | replacements->newReplacement(picture->uniqueID(), |
| 199 | layer->start(), |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 200 | combined); |
robertphillips | ed42059 | 2014-09-29 11:39:38 -0700 | [diff] [blame] | 201 | layerInfo->fStop = layer->stop(); |
| 202 | layerInfo->fPos = layers[i].fOffset; |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 203 | |
| 204 | SkBitmap bm; |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 205 | wrap_texture(layers[i].fLayer->texture(), |
| 206 | !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().width() |
| 207 | : layers[i].fLayer->texture()->width(), |
| 208 | !layers[i].fLayer->isAtlased() ? layers[i].fLayer->rect().height() |
| 209 | : layers[i].fLayer->texture()->height(), |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 210 | &bm); |
| 211 | layerInfo->fImage = SkImage::NewTexture(bm); |
| 212 | |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 213 | layerInfo->fPaint = layers[i].fLayer->paint() |
| 214 | ? SkNEW_ARGS(SkPaint, (*layers[i].fLayer->paint())) |
| 215 | : NULL; |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 216 | |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 217 | layerInfo->fSrcRect = SkIRect::MakeXYWH(layers[i].fLayer->rect().fLeft, |
| 218 | layers[i].fLayer->rect().fTop, |
| 219 | layers[i].fLayer->rect().width(), |
| 220 | layers[i].fLayer->rect().height()); |
robertphillips | 1c4c528 | 2014-09-18 12:03:15 -0700 | [diff] [blame] | 221 | } |
| 222 | } |
| 223 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 224 | void GrLayerHoister::DrawLayersToAtlas(GrContext* context, |
| 225 | const SkTDArray<GrHoistedLayer>& atlased) { |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 226 | if (atlased.count() > 0) { |
| 227 | // All the atlased layers are rendered into the same GrTexture |
| 228 | SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect( |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 229 | atlased[0].fLayer->texture()->asRenderTarget(), NULL)); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 230 | |
| 231 | SkCanvas* atlasCanvas = surface->getCanvas(); |
| 232 | |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 233 | SkPaint clearPaint; |
| 234 | clearPaint.setColor(SK_ColorTRANSPARENT); |
| 235 | clearPaint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref(); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 236 | |
| 237 | for (int i = 0; i < atlased.count(); ++i) { |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 238 | const GrCachedLayer* layer = atlased[i].fLayer; |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 239 | const SkPicture* pict = atlased[i].fPicture; |
robertphillips | ed42059 | 2014-09-29 11:39:38 -0700 | [diff] [blame] | 240 | const SkIPoint offset = atlased[i].fOffset; |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 241 | SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();) |
| 242 | |
| 243 | SkASSERT(!layerPaint || !layerPaint->getImageFilter()); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 244 | |
| 245 | atlasCanvas->save(); |
| 246 | |
| 247 | // Add a rect clip to make sure the rendering doesn't |
| 248 | // extend beyond the boundaries of the atlased sub-rect |
| 249 | SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft), |
| 250 | SkIntToScalar(layer->rect().fTop), |
| 251 | SkIntToScalar(layer->rect().width()), |
| 252 | SkIntToScalar(layer->rect().height())); |
| 253 | atlasCanvas->clipRect(bound); |
| 254 | |
| 255 | // Since 'clear' doesn't respect the clip we need to draw a rect |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 256 | atlasCanvas->drawRect(bound, clearPaint); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 257 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 258 | // '-offset' maps the layer's top/left to the origin. |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 259 | // Since this layer is atlased, the top/left corner needs |
| 260 | // to be offset to the correct location in the backing texture. |
robertphillips | 4815fe5 | 2014-09-16 10:32:43 -0700 | [diff] [blame] | 261 | SkMatrix initialCTM; |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 262 | initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY)); |
| 263 | initialCTM.preTranslate(bound.fLeft, bound.fTop); |
| 264 | initialCTM.preConcat(atlased[i].fPreMat); |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 265 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 266 | atlasCanvas->setMatrix(initialCTM); |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 267 | atlasCanvas->concat(atlased[i].fLocalMat); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 268 | |
reed | 6be2aa9 | 2014-11-18 11:08:05 -0800 | [diff] [blame^] | 269 | SkRecordPartialDraw(*pict->fRecord.get(), atlasCanvas, |
| 270 | pict->drawablePicts(), pict->drawableCount(), |
| 271 | bound, layer->start() + 1, layer->stop(), initialCTM); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 272 | |
| 273 | atlasCanvas->restore(); |
| 274 | } |
| 275 | |
| 276 | atlasCanvas->flush(); |
| 277 | } |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 278 | } |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 279 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 280 | void GrLayerHoister::DrawLayers(GrContext* context, const SkTDArray<GrHoistedLayer>& layers) { |
| 281 | for (int i = 0; i < layers.count(); ++i) { |
| 282 | GrCachedLayer* layer = layers[i].fLayer; |
| 283 | const SkPicture* pict = layers[i].fPicture; |
| 284 | const SkIPoint& offset = layers[i].fOffset; |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 285 | |
| 286 | // Each non-atlased layer has its own GrTexture |
| 287 | SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect( |
reed | 4a8126e | 2014-09-22 07:29:03 -0700 | [diff] [blame] | 288 | layer->texture()->asRenderTarget(), NULL)); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 289 | |
| 290 | SkCanvas* layerCanvas = surface->getCanvas(); |
| 291 | |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 292 | SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop); |
| 293 | |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 294 | // Add a rect clip to make sure the rendering doesn't |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 295 | // extend beyond the boundaries of the layer |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 296 | SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft), |
| 297 | SkIntToScalar(layer->rect().fTop), |
| 298 | SkIntToScalar(layer->rect().width()), |
| 299 | SkIntToScalar(layer->rect().height())); |
| 300 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 301 | layerCanvas->clipRect(bound); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 302 | |
| 303 | layerCanvas->clear(SK_ColorTRANSPARENT); |
| 304 | |
robertphillips | 4815fe5 | 2014-09-16 10:32:43 -0700 | [diff] [blame] | 305 | SkMatrix initialCTM; |
robertphillips | 9e6835d | 2014-10-22 05:33:52 -0700 | [diff] [blame] | 306 | initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY)); |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 307 | initialCTM.preConcat(layers[i].fPreMat); |
robertphillips | 4815fe5 | 2014-09-16 10:32:43 -0700 | [diff] [blame] | 308 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 309 | layerCanvas->setMatrix(initialCTM); |
| 310 | layerCanvas->concat(layers[i].fLocalMat); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 311 | |
reed | 6be2aa9 | 2014-11-18 11:08:05 -0800 | [diff] [blame^] | 312 | SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas, |
| 313 | pict->drawablePicts(), pict->drawableCount(), |
| 314 | bound, layer->start()+1, layer->stop(), initialCTM); |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 315 | |
| 316 | layerCanvas->flush(); |
| 317 | } |
| 318 | } |
| 319 | |
robertphillips | d61ef01 | 2014-10-08 05:17:02 -0700 | [diff] [blame] | 320 | void GrLayerHoister::UnlockLayers(GrContext* context, |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 321 | const SkTDArray<GrHoistedLayer>& layers) { |
robertphillips | d61ef01 | 2014-10-08 05:17:02 -0700 | [diff] [blame] | 322 | GrLayerCache* layerCache = context->getLayerCache(); |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 323 | |
robertphillips | fd61ed0 | 2014-10-28 07:21:44 -0700 | [diff] [blame] | 324 | for (int i = 0; i < layers.count(); ++i) { |
| 325 | layerCache->removeUse(layers[i].fLayer); |
robertphillips | b5a9715 | 2014-09-30 11:33:02 -0700 | [diff] [blame] | 326 | } |
| 327 | |
robertphillips | 4ab5a90 | 2014-10-29 13:56:02 -0700 | [diff] [blame] | 328 | SkDEBUGCODE(layerCache->validate();) |
| 329 | } |
| 330 | |
| 331 | void GrLayerHoister::PurgeCache(GrContext* context) { |
| 332 | #if !GR_CACHE_HOISTED_LAYERS |
| 333 | GrLayerCache* layerCache = context->getLayerCache(); |
| 334 | |
robertphillips | 30d2cc6 | 2014-09-24 08:52:18 -0700 | [diff] [blame] | 335 | // This code completely clears out the atlas. It is required when |
| 336 | // caching is disabled so the atlas doesn't fill up and force more |
| 337 | // free floating layers |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 338 | layerCache->purgeAll(); |
| 339 | #endif |
robertphillips | 98d709b | 2014-09-02 10:20:50 -0700 | [diff] [blame] | 340 | } |