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