Generate Signed Distance Field directly from vector path

src/core/SkDistanceFieldGen.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDistanceFieldGen.h"
 #include "SkPoint.h"
 
@@ skipping 299 matching lines @@
         curr->fDistSq = distSq;
         curr->fDistVector = distVec;
     }
 }
 
 // enable this to output edge data rather than the distance field
 #define DUMP_EDGE 0
 
 #if !DUMP_EDGE
 static unsigned char pack_distance_field_val(float dist, float distanceMagnitude) {
-    if (dist <= -distanceMagnitude) {
-        return 255;
-    } else if (dist > distanceMagnitude) {
-        return 0;
-    } else {
-        return (unsigned char)((distanceMagnitude-dist)*128.0f/distanceMagnitude);
-    }
+    // The distance field is constructed as unsigned char values, so that the zero value is at 128,

[jvanverth1, 2016/02/19 23:36:46]

I was looking at this to understand it a little better, so I could possibly
submit it separately a little early (we have a Chrome branch coming up next
week). However, it looks like (-31/32, 0] maps to 128 (this was true of the
original code). I was thinking it might be better to have the values surrounding
0 map to 128, e.g. (-31/64, 31/64]. What do you think?

[Joel.Liang, 2016/02/22 07:34:00]

Yes, to do that we could add SkScalarRoundToInt to the return statement:
    return (unsigned char)SkScalarRoundToInt(dist / (2 * distanceMagnitude) *
256.0f);

And it's safe, because we have truncated the input by multiply 127/128. (It will
truncate the result which greater than 255.0)

+    // Beside 128, we have 128 values in range [0, 128), but only 127 values in range (128, 255].
+    // So we multiply distanceMagnitude by 127/128 at the latter range to avoid overflow.
+    dist = SkScalarPin(-dist, -distanceMagnitude, distanceMagnitude * 127.0f / 128.0f);
+
+    // Scale into the positive range for unsigned distance
+    dist += distanceMagnitude;
+
+    // Scale into unsigned char range
+    return (unsigned char)(dist / (2 * distanceMagnitude) * 256.0f);
 }
 #endif
 
 // assumes a padded 8-bit image and distance field
 // width and height are the original width and height of the image
 static bool generate_distance_field_from_image(unsigned char* distanceField,
                                                const unsigned char* copyPtr,
                                                int width, int height) {
     SkASSERT(distanceField);
     SkASSERT(copyPtr);
@@ skipping 170 matching lines @@
                 *currDestPtr++ = (mask & (1 << i)) ? 0xff : 0;
             }
         }
         currSrcScanLine += rowBytes;
         *currDestPtr++ = 0;
     }
     sk_bzero(currDestPtr, (width+2)*sizeof(char));
 
     return generate_distance_field_from_image(distanceField, copyPtr, width, height);
 }