Use per-typeface sets of glyphs for nvpr text

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 14 matching lines @@
 class GrEffect;
 class GrFontCache;
 class GrGpu;
 class GrGpuTraceMarker;
 class GrIndexBuffer;
 class GrIndexBufferAllocPool;
 class GrInOrderDrawBuffer;
 class GrLayerCache;
 class GrOvalRenderer;
 class GrPath;
+class GrPathRange;
 class GrPathRenderer;
 class GrResourceEntry;
 class GrResourceCache;
 class GrResourceCache2;
 class GrStencilBuffer;
 class GrTestTarget;
 class GrTextContext;
 class GrTextureParams;
 class GrVertexBuffer;
 class GrVertexBufferAllocPool;
 class GrStrokeInfo;
 class GrSoftwarePathRenderer;
+class SkDescriptor;
 class SkStrokeRec;
+class SkTypeface;
 
 class SK_API GrContext : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrContext)
 
     struct Options {
         Options() : fDrawPathToCompressedTexture(false) { }
 
         // EXPERIMENTAL
         // May be removed in the future, or may become standard depending
@@ skipping 999 matching lines @@
 
     /** Creates a new gpu path, based on the specified path and stroke and returns it.
      * The caller owns a ref on the returned path which must be balanced by a call to unref.
      *
      * @param skPath the path geometry.
      * @param stroke the path stroke.
      * @return a new path or NULL if the operation is not supported by the backend.
      */
     GrPath* createPath(const SkPath& skPath, const SkStrokeRec& stroke);
 
+    /**
+     * Creates a range of glyph paths, indexed by glyph id. The glyphs will have an

[bsalomon, 2014/09/15 14:16:21]

Does this have to go here or can it go in the text context?

[Chris Dalton, 2014/09/15 21:05:25]

I put it here because I thought it ought to follow the same pattern as
createPath(), but it could also go in the text context if you think that makes
more sense.

+     * inverted y-direction in order to match the raw font path data.
+     *
+     * @param SkTypeface   Typeface that defines the glyphs.
+     *                     If null, the default typeface will be used.
+     *
+     * @param SkDescriptor Additional font configuration that specifies the font's size,
+     *                     stroke, and other flags. This will generally come from an
+     *                     SkGlyphCache.
+     *
+     *                     It is recommended to leave this value null when possible, in
+     *                     which case the glyphs will be loaded directly from the font's
+     *                     raw path data and sized at SkPaint::kCanonicalTextSizeForPaths.
+     *                     This results in less memory usage and more efficient GPU paths.
+     *
+     *                     If non-null, the glyph paths will match the font descriptor,
+     *                     including with the stroke information baked directly into
+     *                     the outlines.
+     *
+     * @param SkStrokeRec  Common stroke that the GPU will apply to every path. Note
+     *                     that if the glyph outlines contain strokes from the font
+     *                     descriptor, this stroke will be applied on top of those
+     *                     outlines.
+     *
+     * It is only legal to call this if the gpu supports path rendering.
+     */
+    GrPathRange* createGlyphs(const SkTypeface*, const SkDescriptor*, const SkStrokeRec&);
+
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * Gets and locks a scratch texture from a descriptor using either exact or approximate criteria.
  * Unlocks texture in the destructor.
  */
 class GrAutoScratchTexture : public ::SkNoncopyable {
 public:
     GrAutoScratchTexture()
@@ skipping 70 matching lines @@
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif