Implement text rendering with NVPR

src/core/SkDrawProcs.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDrawProcs_DEFINED
 #define SkDrawProcs_DEFINED
 
 #include "SkBlitter.h"
 #include "SkDraw.h"
+#include "SkGlyph.h"
 
 class SkAAClip;
 class SkBlitter;
 
 struct SkDraw1Glyph {
     const SkDraw* fDraw;
     const SkRegion* fClip;
     const SkAAClip* fAAClip;
     SkBlitter* fBlitter;
     SkGlyphCache* fCache;
@@ skipping 56 matching lines @@
         return true;
     }
 
     if (!paint.isAntiAlias()) {
         return false;
     }
 
     return SkDrawTreatAAStrokeAsHairline(strokeWidth, matrix, coverage);
 }
 
+class SkTextAlignProc {
+public:
+    SkTextAlignProc(SkPaint::Align align)
+        : fAlign(align) {
+    }
+
+    // Returns the position of the glyph in fixed point, which may be rounded or not
+    //         by the caller e.g. subpixel doesn't round.
+    // @param point interpreted as SkFixed [x, y].
+    void operator()(const SkPoint& loc, const SkGlyph& glyph, SkIPoint* dst) {
+        if (SkPaint::kLeft_Align == fAlign) {

[jvanverth1, 2014/06/09 13:48:07]

If I understand this correctly, this seems inefficient. The point of the procs
is to do the conditional check once and then just call the appropriate function.
Have you done a comparison between this and the old Bitmap code using 'bench' or
'bench_pictures'?

[Kimmo Kinnunen, 2014/06/11 12:33:24]

I'm not an expert, but afaik function pointers aren't really efficient with
modern compilers and processors. The compiler can avoid the call and the checks
if function pointers are not used.

The change is neutral or very slight perf increase, from what I can test.

If we are micro-optimizing now, then it probably would make sense to transform
the TextMapState to same pattern. I changed the new patch to this. Results are
in the main comments.

+            dst->set(SkScalarToFixed(loc.fX), SkScalarToFixed(loc.fY));
+        } else if (SkPaint::kCenter_Align == fAlign) {
+            dst->set(SkScalarToFixed(loc.fX) - (glyph.fAdvanceX >> 1),
+                     SkScalarToFixed(loc.fY) - (glyph.fAdvanceY >> 1));
+        } else {
+            SkASSERT(SkPaint::kRight_Align == fAlign);
+            dst->set(SkScalarToFixed(loc.fX) - glyph.fAdvanceX,
+                     SkScalarToFixed(loc.fY) - glyph.fAdvanceY);
+        }
+    }
+private:
+    const SkPaint::Align fAlign;
+};
+
+class SkTextAlignProcScalar {
+public:
+    SkTextAlignProcScalar(SkPaint::Align align)
+        : fAlign(align) {
+    }
+
+    // Returns the glyph position, which may be rounded or not by the caller
+    //   e.g. subpixel doesn't round.
+    void operator()(const SkPoint& loc, const SkGlyph& glyph, SkPoint* dst) {
+        if (SkPaint::kLeft_Align == fAlign) {
+            dst->set(loc.fX, loc.fY);
+        } else if (SkPaint::kCenter_Align == fAlign) {
+            dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX >> 1),
+                     loc.fY - SkFixedToScalar(glyph.fAdvanceY >> 1));
+        } else {
+            SkASSERT(SkPaint::kRight_Align == fAlign);
+            dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX),
+                     loc.fY - SkFixedToScalar(glyph.fAdvanceY));
+        }
+    }
+private:
+    const SkPaint::Align fAlign;
+};
+
 #endif