Proposed SkCanvas API for preLoading textures to VRAM v2.0

include/core/SkPicture.h

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPicture_DEFINED
@@ skipping 16 matching lines @@
 
 /** \class SkPicture
 
     The SkPicture class records the drawing commands made to a canvas, to
     be played back at a later time.
 */
 class SK_API SkPicture : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkPicture)
 
+    // SkAccelData provides a base class for device-specific acceleration
+    // data. It is added to the picture via a call to a device's optimize 
+    // method.
+    class SkAccelData : public SkRefCnt {
+    public:
+        SkAccelData(uint32_t id) : fID(id) { }
+
+        uint32_t getID() const { return fID; }
+
+    private:
+        uint32_t fID;
+
+        typedef SkRefCnt INHERITED;
+    };
+
     /** The constructor prepares the picture to record.
         @param width the width of the virtual device the picture records.
         @param height the height of the virtual device the picture records.
     */
     SkPicture();
     /** Make a copy of the contents of src. If src records more drawing after
         this call, those elements will not appear in this picture.
     */
     SkPicture(const SkPicture& src);
 
+    void setAccelData(const SkAccelData* data) { SkRefCnt_SafeAssign(fAccelData, data); }

[bsalomon, 2014/03/12 15:34:34]

If we ever have other backends that want to optimize then we may want to store
the accel in some hash (so that there can be multiple) and have the get() take
an id and produce a matching accel if one has been added with that id..

[robertphillips, 2014/03/13 12:43:42]

Done. I have updated the interface to support this but would like to delay
(until Mike K is around) before tangling with SkTDynamicHash again
(https://codereview.chromium.org/197443003/).

+    const SkAccelData* getAccelData() const { return fAccelData; }
+
     /**
      *  Function signature defining a function that sets up an SkBitmap from encoded data. On
      *  success, the SkBitmap should have its Config, width, height, rowBytes and pixelref set.
      *  If the installed pixelref has decoded the data into pixels, then the src buffer need not be
      *  copied. If the pixelref defers the actual decode until its lockPixels() is called, then it
      *  must make a copy of the src buffer.
      *  @param src Encoded data.
      *  @param length Size of the encoded data, in bytes.
      *  @param dst SkBitmap to install the pixel ref on.
      *  @param bool Whether or not a pixel ref was successfully installed.
@@ skipping 198 matching lines @@
     // Note: If the picture version needs to be increased then please follow the
     // steps to generate new SKPs in (only accessible to Googlers): http://goo.gl/qATVcw
 
     // Only SKPs within the min/current picture version range (inclusive) can be read.
     static const uint32_t MIN_PICTURE_VERSION = 19;
     static const uint32_t CURRENT_PICTURE_VERSION = 22;
 
     // fPlayback, fRecord, fWidth & fHeight are protected to allow derived classes to
     // install their own SkPicturePlayback-derived players,SkPictureRecord-derived
     // recorders and set the picture size
-    SkPicturePlayback* fPlayback;
-    SkPictureRecord* fRecord;
-    int fWidth, fHeight;
+    SkPicturePlayback*    fPlayback;
+    SkPictureRecord*      fRecord;
+    int                   fWidth, fHeight;
+    const SkAccelData*    fAccelData;
 
     // Create a new SkPicture from an existing SkPicturePlayback. Ref count of
     // playback is unchanged.
     SkPicture(SkPicturePlayback*, int width, int height);
 
     // For testing. Derived classes may instantiate an alternate
     // SkBBoxHierarchy implementation
     virtual SkBBoxHierarchy* createBBoxHierarchy() const;
 private:
     void createHeader(void* header) const;
@@ skipping 16 matching lines @@
  */
 class SK_API SkDrawPictureCallback {
 public:
     SkDrawPictureCallback() {}
     virtual ~SkDrawPictureCallback() {}
 
     virtual bool abortDrawing() = 0;
 };
 
 #endif