Proposed SkCanvas API for preLoading textures to VRAM v2.0

tools/PictureRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 552 matching lines @@
                                                         SkIntToScalar(fTileHeight));
                 tile_x_start += current_width;
             }
 
             current_width >>= 1;
         }
     }
 }
 
 /**
- * Draw the specified playback to the canvas translated to rectangle provided, so that this mini
+ * Draw the specified picture to the canvas translated to rectangle provided, so that this mini
  * canvas represents the rectangle's portion of the overall picture.
  * Saves and restores so that the initial clip and matrix return to their state before this function
  * is called.
  */
-template<class T>
-static void DrawTileToCanvas(SkCanvas* canvas, const SkRect& tileRect, T* playback) {
+static void draw_tile_to_canvas(SkCanvas* canvas, const SkRect& tileRect, SkPicture* picture) {
     int saveCount = canvas->save();
     // Translate so that we draw the correct portion of the picture.
     // Perform a postTranslate so that the scaleFactor does not interfere with the positioning.
     SkMatrix mat(canvas->getTotalMatrix());
     mat.postTranslate(-tileRect.fLeft, -tileRect.fTop);
     canvas->setMatrix(mat);
-    playback->draw(canvas);
+    canvas->drawPicture(*picture);
     canvas->restoreToCount(saveCount);
     canvas->flush();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Copies the entirety of the src bitmap (typically a tile) into a portion of the dst bitmap.
  * If the src bitmap is too large to fit within the dst bitmap after the x and y
  * offsets have been applied, any excess will be ignored (so only the top-left portion of the
@@ skipping 17 matching lines @@
     if (++fCurrentTileOffset < fTileRects.count()) {
         i = fCurrentTileOffset % fTilesX;
         j = fCurrentTileOffset / fTilesX;
         return true;
     }
     return false;
 }
 
 void TiledPictureRenderer::drawCurrentTile() {
     SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count());
-    DrawTileToCanvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
+    draw_tile_to_canvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
 }
 
 bool TiledPictureRenderer::render(const SkString* path, SkBitmap** out) {
     SkASSERT(fPicture != NULL);
     if (NULL == fPicture) {
         return false;
     }
 
     SkBitmap bitmap;
     if (out){
         *out = SkNEW(SkBitmap);
         setup_bitmap(*out, fPicture->width(), fPicture->height());
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
     bool success = true;
     for (int i = 0; i < fTileRects.count(); ++i) {
-        DrawTileToCanvas(fCanvas, fTileRects[i], fPicture);
+        draw_tile_to_canvas(fCanvas, fTileRects[i], fPicture);
         if (NULL != path) {
             success &= writeAppendNumber(fCanvas, path, i, fJsonSummaryPtr);
         }
         if (NULL != out) {
             if (fCanvas->readPixels(&bitmap, 0, 0)) {
                 // Add this tile to the entire bitmap.
                 bitmapCopyAtOffset(bitmap, *out, SkScalarFloorToInt(fTileRects[i].left()),
                                    SkScalarFloorToInt(fTileRects[i].top()));
             } else {
                 success = false;
@@ skipping 63 matching lines @@
     virtual void run() SK_OVERRIDE {
         SkGraphics::SetTLSFontCacheLimit(1024 * 1024);
 
         SkBitmap bitmap;
         if (fBitmap != NULL) {
             // All tiles are the same size.
             setup_bitmap(&bitmap, SkScalarFloorToInt(fRects[0].width()), SkScalarFloorToInt(fRects[0].height()));
         }
 
         for (int i = fStart; i < fEnd; i++) {
-            DrawTileToCanvas(fCanvas, fRects[i], fClone);
+            draw_tile_to_canvas(fCanvas, fRects[i], fClone);
             if ((fPath != NULL) && !writeAppendNumber(fCanvas, fPath, i, fJsonSummaryPtr)
                 && fSuccess != NULL) {
                 *fSuccess = false;
                 // If one tile fails to write to a file, do not continue drawing the rest.
                 break;
             }
             if (fBitmap != NULL) {
                 if (fCanvas->readPixels(&bitmap, 0, 0)) {
                     SkAutoLockPixels alp(*fBitmap);
                     bitmapCopyAtOffset(bitmap, fBitmap, SkScalarFloorToInt(fRects[i].left()),
@@ skipping 218 matching lines @@
     virtual SkString getConfigNameInternal() SK_OVERRIDE {
         return SkString("picture_clone");
     }
 };
 
 PictureRenderer* CreatePictureCloneRenderer() {
     return SkNEW(PictureCloneRenderer);
 }
 
 } // namespace sk_tools