static HB_Error getOutlinePoint(HB_Font hbFont, HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed* xPos, HB_Fixed* yPos, hb_uint32* resultingNumPoints)
{
FontPlatformData* font = reinterpret_cast<FontPlatformData*>(hbFont->userData);
SkPaint paint;
if (flags & HB_ShaperFlag_UseDesignMetrics)
return HB_Err_Invalid_Argument; // This is requesting pre-hinted positions. We can't support this.
font->setupPaint(&paint);
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
uint16_t glyph16 = glyph;
SkPath path;
paint.getTextPath(&glyph16, sizeof(glyph16), 0, 0, &path);
int numPoints = path.getPoints(0, 0);
if (point >= static_cast<unsigned>(numPoints))
return HB_Err_Invalid_SubTable;
SkPoint* points = reinterpret_cast<SkPoint*>(fastMalloc(sizeof(SkPoint) * (point + 1)));
if (!points)
return HB_Err_Invalid_SubTable;
// Skia does let us get a single point from the path.
path.getPoints(points, point + 1);
*xPos = SkiaScalarToHarfbuzzFixed(points[point].fX);
*yPos = SkiaScalarToHarfbuzzFixed(points[point].fY);
*resultingNumPoints = numPoints;
fastFree(points);
return HB_Err_Ok;
}
static HB_Error getOutlinePoint(HB_Font hbFont, HB_Glyph glyph, int flags, hb_uint32 point,
HB_Fixed* xPos, HB_Fixed* yPos, hb_uint32* resultingNumPoints)
{
if (flags & HB_ShaperFlag_UseDesignMetrics)
// This is requesting pre-hinted positions. We can't support this.
return HB_Err_Invalid_Argument;
SkPaint* paint = static_cast<SkPaint*>(hbFont->userData);
paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
uint16_t glyph16 = glyph;
SkPath path;
paint->getTextPath(&glyph16, sizeof(glyph16), 0, 0, &path);
uint32_t numPoints = path.getPoints(0, 0);
if (point >= numPoints)
return HB_Err_Invalid_SubTable;
SkPoint* points = static_cast<SkPoint*>(malloc(sizeof(SkPoint) * (point + 1)));
if (!points)
return HB_Err_Invalid_SubTable;
// Skia does let us get a single point from the path.
path.getPoints(points, point + 1);
*xPos = SkScalarToHBFixed(points[point].fX);
*yPos = SkScalarToHBFixed(points[point].fY);
*resultingNumPoints = numPoints;
delete points;
return HB_Err_Ok;
}
GrGLPath::GrGLPath(GrGpuGL* gpu, const SkPath& path) : INHERITED(gpu, kIsWrapped) {
#ifndef SK_SCALAR_IS_FLOAT
GrCrash("Assumes scalar is float.");
#endif
SkASSERT(!path.isEmpty());
GL_CALL_RET(fPathID, GenPaths(1));
SkSTArray<16, GrGLubyte, true> pathCommands;
SkSTArray<16, SkPoint, true> pathPoints;
int verbCnt = path.countVerbs();
int pointCnt = path.countPoints();
pathCommands.resize_back(verbCnt);
pathPoints.resize_back(pointCnt);
// TODO: Direct access to path points since we could pass them on directly.
path.getPoints(&pathPoints[0], pointCnt);
path.getVerbs(&pathCommands[0], verbCnt);
GR_DEBUGCODE(int numPts = 0);
for (int i = 0; i < verbCnt; ++i) {
SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]);
pathCommands[i] = verb_to_gl_path_cmd(v);
GR_DEBUGCODE(numPts += num_pts(v));
}
GrAssert(pathPoints.count() == numPts);
GL_CALL(PathCommands(fPathID,
verbCnt, &pathCommands[0],
2 * pointCnt, GR_GL_FLOAT, &pathPoints[0]));
fBounds = path.getBounds();
}
static void show_fan(SkCanvas* canvas, const SkPath& path, SkScalar cx, SkScalar cy) {
SkPaint paint;
setGLFrame(&paint);
canvas->drawPath(path, paint);
SkPoint pts[256];
int count = path.getPoints(pts, SK_ARRAY_COUNT(pts));
for (int i = 0; i < count; ++i) {
canvas->drawLine(pts[i].fX, pts[i].fY, cx, cy, paint);
}
}
static void draw_path(SkCanvas* canvas, const SkPaint& pathPaint,
const SkPath& path, const SkPaint& triPaint) {
canvas->drawPath(path, pathPaint);
int n = path.getPoints(NULL, 0);
SkPoint* pts = new SkPoint[n];
path.getPoints(pts, n);
SkTDArray<SkPoint> triangles;
if (SkConcaveToTriangles(n, pts, &triangles)) {
canvas->drawVertices(SkCanvas::kTriangles_VertexMode,
triangles.count(), triangles.begin(), NULL,
NULL, NULL, NULL, 0, triPaint);
}
SkPaint paint;
paint.setColor(SK_ColorGREEN);
paint.setStrokeWidth(SkIntToScalar(4));
canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, paint);
delete[] pts;
}
void GrGLPath::InitPathObjectPathData(GrGLGpu* gpu,
GrGLuint pathID,
const SkPath& skPath) {
SkASSERT(!skPath.isEmpty());
#ifdef SK_SCALAR_IS_FLOAT
// This branch does type punning, converting SkPoint* to GrGLfloat*.
if ((skPath.getSegmentMasks() & SkPath::kConic_SegmentMask) == 0) {
int verbCnt = skPath.countVerbs();
int pointCnt = skPath.countPoints();
int coordCnt = pointCnt * 2;
SkSTArray<16, GrGLubyte, true> pathCommands(verbCnt);
SkSTArray<16, GrGLfloat, true> pathCoords(coordCnt);
static_assert(sizeof(SkPoint) == sizeof(GrGLfloat) * 2, "sk_point_not_two_floats");
pathCommands.resize_back(verbCnt);
pathCoords.resize_back(coordCnt);
skPath.getPoints(reinterpret_cast<SkPoint*>(&pathCoords[0]), pointCnt);
skPath.getVerbs(&pathCommands[0], verbCnt);
SkDEBUGCODE(int verbCoordCnt = 0);
for (int i = 0; i < verbCnt; ++i) {
SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]);
pathCommands[i] = verb_to_gl_path_cmd(v);
SkDEBUGCODE(verbCoordCnt += num_coords(v));
}
SkASSERT(verbCnt == pathCommands.count());
SkASSERT(verbCoordCnt == pathCoords.count());
SkDEBUGCODE(verify_floats(&pathCoords[0], pathCoords.count()));
GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
pathCoords.count(), GR_GL_FLOAT,
&pathCoords[0]));
return;
}
#endif
SkAssertResult(init_path_object_for_general_path<false>(gpu, pathID, skPath));
}
static void draw_path(SkCanvas* canvas, const SkPath& path, const SkRect& rect,
SkPaint::Join join, int doFill) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(doFill ? SkPaint::kStrokeAndFill_Style : SkPaint::kStroke_Style);
paint.setColor(sk_tool_utils::color_to_565(SK_ColorGRAY));
paint.setStrokeWidth(STROKE_WIDTH);
paint.setStrokeJoin(join);
canvas->drawRect(rect, paint);
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(0);
paint.setColor(SK_ColorRED);
canvas->drawPath(path, paint);
paint.setStrokeWidth(3);
paint.setStrokeJoin(SkPaint::kMiter_Join);
int n = path.countPoints();
SkAutoTArray<SkPoint> points(n);
path.getPoints(points.get(), n);
canvas->drawPoints(SkCanvas::kPoints_PointMode, n, points.get(), paint);
}
void draw_points(SkCanvas* canvas, const SkPath& path, SkColor color,
bool show_lines) {
SkPaint paint;
paint.setColor(color);
paint.setAlpha(0x80);
paint.setAntiAlias(true);
int n = path.countPoints();
SkAutoSTArray<32, SkPoint> pts(n);
if (show_lines && fDrawTangents) {
SkTArray<int> contourCounts;
getContourCounts(path, &contourCounts);
SkPoint* ptPtr = pts.get();
for (int i = 0; i < contourCounts.count(); ++i) {
int count = contourCounts[i];
path.getPoints(ptPtr, count);
canvas->drawPoints(SkCanvas::kPolygon_PointMode, count, ptPtr, paint);
ptPtr += count;
}
} else {
n = getOnCurvePoints(path, pts.get());
}
paint.setStrokeWidth(5);
canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts.get(), paint);
}
void GrGLPath::InitPathObject(GrGLGpu* gpu,
GrGLuint pathID,
const SkPath& skPath,
const GrStrokeInfo& stroke) {
SkASSERT(!stroke.isDashed());
if (!skPath.isEmpty()) {
int verbCnt = skPath.countVerbs();
int pointCnt = skPath.countPoints();
int minCoordCnt = pointCnt * 2;
SkSTArray<16, GrGLubyte, true> pathCommands(verbCnt);
SkSTArray<16, GrGLfloat, true> pathCoords(minCoordCnt);
SkDEBUGCODE(int numCoords = 0);
if ((skPath.getSegmentMasks() & SkPath::kConic_SegmentMask) == 0) {
// This branch does type punning, converting SkPoint* to GrGLfloat*.
SK_COMPILE_ASSERT(sizeof(SkPoint) == sizeof(GrGLfloat) * 2, sk_point_not_two_floats);
// This branch does not convert with SkScalarToFloat.
#ifndef SK_SCALAR_IS_FLOAT
#error Need SK_SCALAR_IS_FLOAT.
#endif
pathCommands.resize_back(verbCnt);
pathCoords.resize_back(minCoordCnt);
skPath.getPoints(reinterpret_cast<SkPoint*>(&pathCoords[0]), pointCnt);
skPath.getVerbs(&pathCommands[0], verbCnt);
for (int i = 0; i < verbCnt; ++i) {
SkPath::Verb v = static_cast<SkPath::Verb>(pathCommands[i]);
pathCommands[i] = verb_to_gl_path_cmd(v);
SkDEBUGCODE(numCoords += num_coords(v));
}
} else {
SkPoint points[4];
SkPath::RawIter iter(skPath);
SkPath::Verb verb;
while ((verb = iter.next(points)) != SkPath::kDone_Verb) {
pathCommands.push_back(verb_to_gl_path_cmd(verb));
GrGLfloat coords[6];
int coordsForVerb;
switch (verb) {
case SkPath::kMove_Verb:
points_to_coords(points, 0, 1, coords);
coordsForVerb = 2;
break;
case SkPath::kLine_Verb:
points_to_coords(points, 1, 1, coords);
coordsForVerb = 2;
break;
case SkPath::kConic_Verb:
points_to_coords(points, 1, 2, coords);
coords[4] = SkScalarToFloat(iter.conicWeight());
coordsForVerb = 5;
break;
case SkPath::kQuad_Verb:
points_to_coords(points, 1, 2, coords);
coordsForVerb = 4;
break;
case SkPath::kCubic_Verb:
points_to_coords(points, 1, 3, coords);
coordsForVerb = 6;
break;
case SkPath::kClose_Verb:
continue;
default:
SkASSERT(false); // Not reached.
continue;
}
SkDEBUGCODE(numCoords += num_coords(verb));
pathCoords.push_back_n(coordsForVerb, coords);
}
}
SkASSERT(verbCnt == pathCommands.count());
SkASSERT(numCoords == pathCoords.count());
GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, pathCommands.count(), &pathCommands[0],
pathCoords.count(), GR_GL_FLOAT, &pathCoords[0]));
} else {
GR_GL_CALL(gpu->glInterface(), PathCommands(pathID, 0, NULL, 0, GR_GL_FLOAT, NULL));
}
if (stroke.needToApply()) {
SkASSERT(!stroke.isHairlineStyle());
GR_GL_CALL(gpu->glInterface(),
PathParameterf(pathID, GR_GL_PATH_STROKE_WIDTH, SkScalarToFloat(stroke.getWidth())));
GR_GL_CALL(gpu->glInterface(),
PathParameterf(pathID, GR_GL_PATH_MITER_LIMIT, SkScalarToFloat(stroke.getMiter())));
GrGLenum join = join_to_gl_join(stroke.getJoin());
GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_JOIN_STYLE, join));
GrGLenum cap = cap_to_gl_cap(stroke.getCap());
GR_GL_CALL(gpu->glInterface(), PathParameteri(pathID, GR_GL_PATH_END_CAPS, cap));
GR_GL_CALL(gpu->glInterface(), PathParameterf(pathID, GR_GL_PATH_STROKE_BOUND, 0.02f));
}
}
static int count_char_points(const SkPaint& paint, char c) {
SkPath path;
paint.getTextPath(&c, 1, 0, 0, &path);
return path.getPoints(NULL, 0);
}
