void SkMultiPictureDraw::draw(bool flush) { AutoMPDReset mpdreset(this); #ifdef FORCE_SINGLE_THREAD_DRAWING_FOR_TESTING for (int i = 0; i < fThreadSafeDrawData.count(); ++i) { fThreadSafeDrawData[i].draw(); } #else sk_parallel_for(fThreadSafeDrawData.count(), [&](int i) { fThreadSafeDrawData[i].draw(); }); #endif // N.B. we could get going on any GPU work from this main thread while the CPU work runs. // But in practice, we've either got GPU work or CPU work, not both. const int count = fGPUDrawData.count(); if (0 == count) { return; } #if !defined(SK_IGNORE_GPU_LAYER_HOISTING) && SK_SUPPORT_GPU GrContext* context = fGPUDrawData[0].fCanvas->getGrContext(); SkASSERT(context); // Start by collecting all the layers that are going to be atlased and render // them (if necessary). Hoisting the free floating layers is deferred until // drawing the canvas that requires them. SkTDArray<GrHoistedLayer> atlasedNeedRendering, atlasedRecycled; for (int i = 0; i < count; ++i) { const DrawData& data = fGPUDrawData[i]; // we only expect 1 context for all the canvases SkASSERT(data.fCanvas->getGrContext() == context); if (!data.fPaint) { SkRect clipBounds; if (!data.fCanvas->getClipBounds(&clipBounds)) { continue; } SkMatrix initialMatrix = data.fCanvas->getTotalMatrix(); initialMatrix.preConcat(data.fMatrix); GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget(); SkASSERT(rt); // TODO: sorting the cacheable layers from smallest to largest // would improve the packing and reduce the number of swaps // TODO: another optimization would be to make a first pass to // lock any required layer that is already in the atlas GrLayerHoister::FindLayersToAtlas(context, data.fPicture, initialMatrix, clipBounds, &atlasedNeedRendering, &atlasedRecycled, rt->numColorSamples()); } } GrLayerHoister::DrawLayersToAtlas(context, atlasedNeedRendering); SkTDArray<GrHoistedLayer> needRendering, recycled; #endif for (int i = 0; i < count; ++i) { const DrawData& data = fGPUDrawData[i]; SkCanvas* canvas = data.fCanvas; const SkPicture* picture = data.fPicture; #if !defined(SK_IGNORE_GPU_LAYER_HOISTING) && SK_SUPPORT_GPU if (!data.fPaint) { SkRect clipBounds; if (!canvas->getClipBounds(&clipBounds)) { continue; } SkAutoCanvasMatrixPaint acmp(canvas, &data.fMatrix, data.fPaint, picture->cullRect()); const SkMatrix initialMatrix = canvas->getTotalMatrix(); GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget(); SkASSERT(rt); // Find the layers required by this canvas. It will return atlased // layers in the 'recycled' list since they have already been drawn. GrLayerHoister::FindLayersToHoist(context, picture, initialMatrix, clipBounds, &needRendering, &recycled, rt->numColorSamples()); GrLayerHoister::DrawLayers(context, needRendering); // Render the entire picture using new layers GrRecordReplaceDraw(picture, canvas, context->getLayerCache(), initialMatrix, NULL); GrLayerHoister::UnlockLayers(context, needRendering); GrLayerHoister::UnlockLayers(context, recycled); needRendering.rewind(); recycled.rewind(); } else #endif { canvas->drawPicture(picture, &data.fMatrix, data.fPaint); } if (flush) { canvas->flush(); } } #if !defined(SK_IGNORE_GPU_LAYER_HOISTING) && SK_SUPPORT_GPU GrLayerHoister::UnlockLayers(context, atlasedNeedRendering); GrLayerHoister::UnlockLayers(context, atlasedRecycled); #if !GR_CACHE_HOISTED_LAYERS GrLayerHoister::PurgeCache(context); #endif #endif }