Initial CL to add distance field support to GrAtlasTextContext

src/gpu/GrAtlasTextContext.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlasTextContext_DEFINED
 #define GrAtlasTextContext_DEFINED
 
@@ skipping 10 matching lines @@
 class GrBatchTextStrike;
 class GrPipelineBuilder;
 class GrTextBlobCache;
 
 /*
  * This class implements GrTextContext using standard bitmap fonts, and can also process textblobs.
  * TODO replace GrBitmapTextContext
  */
 class GrAtlasTextContext : public GrTextContext {
 public:
-    static GrAtlasTextContext* Create(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
+    static GrAtlasTextContext* Create(GrContext*, SkGpuDevice*, const SkDeviceProperties&,
+                                      bool enableDistanceFields);

[bsalomon, 2015/04/16 15:03:55]

Maybe more a question for Jim: Should DF enable be on SkDeviceProperties? That
may be a dumb Q. I don't really know all the ways in which it is used.

[jvanverth1, 2015/04/16 15:26:54]

SkDeviceProperties is tied more to the physical device: gamma and pixel
geometry.

 
 private:
-    GrAtlasTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&);
+    GrAtlasTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&,
+                       bool enableDistanceFields);
+    ~GrAtlasTextContext() {}

[bsalomon, 2015/04/16 15:03:55]

override?

[joshualitt, 2015/04/16 15:36:12]

Acknowledged.

 
     bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&,
                  const SkPaint&, const SkMatrix& viewMatrix) override;
 
     void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
                     const SkMatrix& viewMatrix, const char text[], size_t byteLength,
                     SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override;
     void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
                        const SkMatrix& viewMatrix,
                        const char text[], size_t byteLength,
@@ skipping 33 matching lines @@
          * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
          * handle, we have a bit to mark the run as flusahable via rendering as paths.  It is worth
          * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
          * can flush in this manner, so we always allocate vertices for the run, regardless of
          * whether or not it is too large.  The benefit of this strategy is that we can always reuse
          * a blob allocation regardless of viewmatrix changes.  We could store positions for these
          * glyphs.  However, its not clear if this is a win because we'd still have to either go the
          * glyph cache to get the path at flush time, or hold onto the path in the cache, which
          * would greatly increase the memory of these cached items.
          */
         struct Run {

[bsalomon, 2015/04/16 15:03:55]

How much of Run and nested classes really needs to be defined in the header?

Could some of these be declared here and defined in the cpp?

 

[joshualitt, 2015/04/16 15:36:12]

I think they have to be in the header because they are allocated in
GrTextBlobCache.cpp, and used in the cpp.  I could move this whole thing to its
own .h though

             Run()
                 : fColor(GrColor_ILLEGAL)
                 , fInitialized(false)
-                , fDrawAsPaths(false) {
+                , fDrawAsPaths(false){

[bsalomon, 2015/04/16 15:03:55]

I liked that space before "{"

[joshualitt, 2015/04/16 15:36:12]

Acknowledged.

                 fVertexBounds.setLargestInverted();
             }
             struct SubRunInfo {
                 SubRunInfo()
                     : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
                     , fGlyphStartIndex(0)
                     , fGlyphEndIndex(0)
                     , fVertexStartIndex(0)
-                    , fVertexEndIndex(0) {}
+                    , fVertexEndIndex(0)
+                    , fDrawAsDistanceFields(false) {}
                 GrMaskFormat fMaskFormat;
                 uint64_t fAtlasGeneration;
                 uint32_t fGlyphStartIndex;
                 uint32_t fGlyphEndIndex;
                 size_t fVertexStartIndex;
                 size_t fVertexEndIndex;
                 GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
+
+                // distance field properties
+                bool fDrawAsDistanceFields;
+                bool fUseLCDText;
             };
 
             class SubRunInfoArray {
             public:
                 SubRunInfoArray()
                     : fSubRunCount(0)
                     , fSubRunAllocation(kMinSubRuns) {
                     fPtr = reinterpret_cast<SubRunInfo*>(fSubRunStorage.get());
                     this->push_back();
                 }
@@ skipping 101 matching lines @@
 
         void* operator new(size_t, void* p) { return p; }
         void operator delete(void* target, void* placement) {
             ::operator delete(target, placement);
         }
     };
 
     typedef BitmapTextBlob::Run Run;
     typedef Run::SubRunInfo PerSubRunInfo;
 
-    void appendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
-                     GrColor color, GrFontScaler*, const SkIRect& clipRect);
+    inline bool canDrawAsDistanceFields(const SkPaint&, const SkMatrix& viewMatrix);
+    BitmapTextBlob* setupDfBlob(size_t glyphCount, const SkPaint& origPaint,

[bsalomon, 2015/04/16 15:03:55]

DFBlob? With few exceptions I think we usually cap all acronym letters (when
they aren't the first part of a name that begins lowercase, e.g. dfPaint).

[jvanverth1, 2015/04/16 15:26:54]

I agree, DF rather than Df.

[joshualitt, 2015/04/16 15:36:12]

Acknowledged.

+                                const SkMatrix& viewMatrix, SkGlyphCache** cache,
+                                SkPaint* dfPaint, SkScalar* textRatio);
+    void bmpAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
+                        GrColor color, GrFontScaler*, const SkIRect& clipRect);
+    bool dfAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, SkScalar sx, SkScalar sy,
+                       GrColor color, GrFontScaler*, const SkIRect& clipRect, SkScalar textRatio,
+                       const SkMatrix& viewMatrix);
+    inline void appendBigGlyph(BitmapTextBlob* blob, GrGlyph* glyph,

[bsalomon, 2015/04/16 15:03:55]

Does "big" mean path?

[joshualitt, 2015/04/16 15:36:12]

yes

+                               GrFontScaler* scaler, int x, int y);
+    inline void innerAppendGlyph(BitmapTextBlob*, Run*, Run::SubRunInfo*,

[bsalomon, 2015/04/16 15:03:55]

appendGlyphCommon?

[joshualitt, 2015/04/16 15:36:12]

Acknowledged.

+                                 const SkRect& positions, GrColor color,
+                                 size_t vertexStride, bool useVertexColor,
+                                 GrGlyph::PackedID);
 
     inline void flushRunAsPaths(const SkTextBlob::RunIterator&, const SkPaint&, SkDrawFilter*,
                                 const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
                                 SkScalar y);
     inline void flushRun(GrDrawTarget*, GrPipelineBuilder*, BitmapTextBlob*, int run, GrColor,
-                         uint8_t paintAlpha, SkScalar transX, SkScalar transY);
+                         SkScalar transX, SkScalar transY, const SkPaint&);
     inline void flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
                                const GrPaint& grPaint, const GrClip& clip,
                                SkScalar transX, SkScalar transY);
 
     // We have to flush SkTextBlobs differently from drawText / drawPosText
     void flush(GrDrawTarget*, const SkTextBlob*, BitmapTextBlob*, GrRenderTarget*, const SkPaint&,
                const GrPaint&, SkDrawFilter*, const GrClip&, const SkMatrix& viewMatrix,
                const SkIRect& clipBounds, SkScalar x, SkScalar y, SkScalar transX, SkScalar transY);
     void flush(GrDrawTarget*, BitmapTextBlob*, GrRenderTarget*, const SkPaint&,
-               const GrPaint&, const GrClip&, const SkMatrix& viewMatrix);
+               const GrPaint&, const GrClip&);
 
-    void internalDrawText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
-                          GrColor color, const SkMatrix& viewMatrix,
-                          const char text[], size_t byteLength,
-                          SkScalar x, SkScalar y, const SkIRect& clipRect);
-    void internalDrawPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+    // A helper for drawing BitmapText in a run of distance fields
+    inline void fallbackDrawPosText(GrRenderTarget*, const GrClip&,
+                                    const GrPaint&,
+                                    const SkPaint&, const SkMatrix& viewMatrix,
+                                    const SkTArray<char>& fallbackTxt,
+                                    const SkTArray<SkScalar>& fallbackPos,
+                                    int scalarsPerPosition,
+                                    const SkPoint& offset,
+                                    const SkIRect& clipRect);
+
+    void internalDrawBmpText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
                              GrColor color, const SkMatrix& viewMatrix,
                              const char text[], size_t byteLength,
-                             const SkScalar pos[], int scalarsPerPosition,
-                             const SkPoint& offset, const SkIRect& clipRect);
+                             SkScalar x, SkScalar y, const SkIRect& clipRect);
+    void internalDrawBmpPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+                                GrColor color, const SkMatrix& viewMatrix,
+                                const char text[], size_t byteLength,
+                                const SkScalar pos[], int scalarsPerPosition,
+                                const SkPoint& offset, const SkIRect& clipRect);
+
+    void internalDrawDfText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+                            GrColor color, const SkMatrix& viewMatrix,
+                            const char text[], size_t byteLength,
+                            SkScalar x, SkScalar y, const SkIRect& clipRect,
+                            SkScalar textRatio,
+                            SkTArray<char>* fallbackTxt,
+                            SkTArray<SkScalar>* fallbackPos,
+                            SkPoint* offset, const SkPaint& origPaint);
+    void internalDrawDfPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+                               GrColor color, const SkMatrix& viewMatrix,
+                               const char text[], size_t byteLength,
+                               const SkScalar pos[], int scalarsPerPosition,
+                               const SkPoint& offset, const SkIRect& clipRect,
+                               SkScalar textRatio,
+                               SkTArray<char>* fallbackTxt,
+                               SkTArray<SkScalar>* fallbackPos);
 
     // sets up the descriptor on the blob and returns a detached cache.  Client must attach
     inline static GrColor ComputeCanonicalColor(const SkPaint&, bool lcd);
-    inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix& viewMatrix);
+    inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix* viewMatrix, bool noGamma);
     static inline bool MustRegenerateBlob(SkScalar* outTransX, SkScalar* outTransY,
                                           const BitmapTextBlob&, const SkPaint&,
                                           const SkMaskFilter::BlurRec&,
                                           const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
     void regenerateTextBlob(BitmapTextBlob* bmp, const SkPaint& skPaint, GrColor,
                             const SkMatrix& viewMatrix,
                             const SkTextBlob* blob, SkScalar x, SkScalar y,
                             SkDrawFilter* drawFilter, const SkIRect& clipRect);
     inline static bool HasLCD(const SkTextBlob*);
+    inline void initDistanceFieldPaint(SkPaint*, SkScalar* textRatio, const SkMatrix&);
+
+    // Distance field text needs this table to compute a value for use in the fragment shader.
+    // Because the GrAtlasTextContext can go out of scope before the final flush, this needs to be
+    // refcnted and malloced
+    struct DistanceAdjustTable : public SkNVRefCnt<DistanceAdjustTable> {
+        DistanceAdjustTable(float gamma) { this->buildDistanceAdjustTable(gamma); }
+        ~DistanceAdjustTable() { SkDELETE_ARRAY(fTable); }
+
+        void buildDistanceAdjustTable(float gamma);
+
+        SkScalar& operator[] (int i) {
+            return fTable[i];
+        }
+
+        const SkScalar& operator[] (int i) const {
+            return fTable[i];
+        }
+
+        SkScalar* fTable;
+    };
 
     GrBatchTextStrike* fCurrStrike;
     GrTextBlobCache* fCache;
+    bool fEnableDFRendering;
+    SkAutoTUnref<DistanceAdjustTable> fDistanceAdjustTable;
 
     friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif