src/gpu/gl/GrGLPath.cpp - skia - Git at Google


 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "GrGLPath.h"
 #include "GrGLPathRendering.h"
 #include "GrGLGpu.h"

 namespace {
 inline GrGLubyte verb_to_gl_path_cmd(SkPath::Verb verb) {
     static const GrGLubyte gTable[] = {
         GR_GL_MOVE_TO,
         GR_GL_LINE_TO,
         GR_GL_QUADRATIC_CURVE_TO,
         GR_GL_CONIC_CURVE_TO,
         GR_GL_CUBIC_CURVE_TO,
         GR_GL_CLOSE_PATH,
     };
     GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
     GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
     GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
     GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
     GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
     GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);

     SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
     return gTable[verb];
 }

 #ifdef SK_DEBUG
 inline int num_coords(SkPath::Verb verb) {
     static const int gTable[] = {
         2, // move
         2, // line
         4, // quad
         5, // conic
         6, // cubic
         0, // close
     };
     GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
     GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
     GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
     GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
     GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
     GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);

     SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
     return gTable[verb];
 }
 #endif

 inline GrGLenum join_to_gl_join(SkPaint::Join join) {
     static GrGLenum gSkJoinsToGrGLJoins[] = {
         GR_GL_MITER_REVERT,
         GR_GL_ROUND,
         GR_GL_BEVEL
     };
     return gSkJoinsToGrGLJoins[join];
     GR_STATIC_ASSERT(0 == SkPaint::kMiter_Join);
     GR_STATIC_ASSERT(1 == SkPaint::kRound_Join);
     GR_STATIC_ASSERT(2 == SkPaint::kBevel_Join);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkJoinsToGrGLJoins) == SkPaint::kJoinCount);
 }

 inline GrGLenum cap_to_gl_cap(SkPaint::Cap cap) {
     static GrGLenum gSkCapsToGrGLCaps[] = {
         GR_GL_FLAT,
         GR_GL_ROUND,
         GR_GL_SQUARE
     };
     return gSkCapsToGrGLCaps[cap];
     GR_STATIC_ASSERT(0 == SkPaint::kButt_Cap);
     GR_STATIC_ASSERT(1 == SkPaint::kRound_Cap);
     GR_STATIC_ASSERT(2 == SkPaint::kSquare_Cap);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
 }

 inline void points_to_coords(const SkPoint points[], size_t first_point, size_t amount,
                              GrGLfloat coords[]) {
     for (size_t i = 0;  i < amount; ++i) {
         coords[i * 2] =  SkScalarToFloat(points[first_point + i].fX);
         coords[i * 2 + 1] = SkScalarToFloat(points[first_point + i].fY);
     }
 }
 }

 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));
     }
 }

 GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& origStroke)
     : INHERITED(gpu, origSkPath, origStroke),
       fPathID(gpu->glPathRendering()->genPaths(1)) {
     // Convert a dashing to either a stroke or a fill.
     const SkPath* skPath = &origSkPath;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* stroke = &origStroke;
     GrStrokeInfo tmpStroke(SkStrokeRec::kFill_InitStyle);

     if (stroke->isDashed()) {
         if (stroke->applyDashToPath(tmpPath.init(), &tmpStroke, *skPath)) {
             skPath = tmpPath.get();
             stroke = &tmpStroke;
         }
     }

     InitPathObject(gpu, fPathID, *skPath, *stroke);

     fShouldStroke = stroke->needToApply();
     fShouldFill = stroke->isFillStyle() ||
             stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;

     if (fShouldStroke) {
         // FIXME: try to account for stroking, without rasterizing the stroke.
         fBounds.outset(stroke->getWidth(), stroke->getWidth());
     }

     this->registerWithCache();
 }

 void GrGLPath::onRelease() {
     if (0 != fPathID && !this->isWrapped()) {
         static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
         fPathID = 0;
     }

     INHERITED::onRelease();
 }

 void GrGLPath::onAbandon() {
     fPathID = 0;

     INHERITED::onAbandon();
 }

	/*
	* Copyright 2012 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "GrGLPath.h"
	#include "GrGLPathRendering.h"
	#include "GrGLGpu.h"

	namespace {
	inline GrGLubyte verb_to_gl_path_cmd(SkPath::Verb verb) {
	static const GrGLubyte gTable[] = {
	GR_GL_MOVE_TO,
	GR_GL_LINE_TO,
	GR_GL_QUADRATIC_CURVE_TO,
	GR_GL_CONIC_CURVE_TO,
	GR_GL_CUBIC_CURVE_TO,
	GR_GL_CLOSE_PATH,
	};
	GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
	GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
	GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
	GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
	GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
	GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);

	SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
	return gTable[verb];
	}

	#ifdef SK_DEBUG
	inline int num_coords(SkPath::Verb verb) {
	static const int gTable[] = {
	2, // move
	2, // line
	4, // quad
	5, // conic
	6, // cubic
	0, // close
	};
	GR_STATIC_ASSERT(0 == SkPath::kMove_Verb);
	GR_STATIC_ASSERT(1 == SkPath::kLine_Verb);
	GR_STATIC_ASSERT(2 == SkPath::kQuad_Verb);
	GR_STATIC_ASSERT(3 == SkPath::kConic_Verb);
	GR_STATIC_ASSERT(4 == SkPath::kCubic_Verb);
	GR_STATIC_ASSERT(5 == SkPath::kClose_Verb);

	SkASSERT(verb >= 0 && (size_t)verb < SK_ARRAY_COUNT(gTable));
	return gTable[verb];
	}
	#endif

	inline GrGLenum join_to_gl_join(SkPaint::Join join) {
	static GrGLenum gSkJoinsToGrGLJoins[] = {
	GR_GL_MITER_REVERT,
	GR_GL_ROUND,
	GR_GL_BEVEL
	};
	return gSkJoinsToGrGLJoins[join];
	GR_STATIC_ASSERT(0 == SkPaint::kMiter_Join);
	GR_STATIC_ASSERT(1 == SkPaint::kRound_Join);
	GR_STATIC_ASSERT(2 == SkPaint::kBevel_Join);
	GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkJoinsToGrGLJoins) == SkPaint::kJoinCount);
	}

	inline GrGLenum cap_to_gl_cap(SkPaint::Cap cap) {
	static GrGLenum gSkCapsToGrGLCaps[] = {
	GR_GL_FLAT,
	GR_GL_ROUND,
	GR_GL_SQUARE
	};
	return gSkCapsToGrGLCaps[cap];
	GR_STATIC_ASSERT(0 == SkPaint::kButt_Cap);
	GR_STATIC_ASSERT(1 == SkPaint::kRound_Cap);
	GR_STATIC_ASSERT(2 == SkPaint::kSquare_Cap);
	GR_STATIC_ASSERT(SK_ARRAY_COUNT(gSkCapsToGrGLCaps) == SkPaint::kCapCount);
	}

	inline void points_to_coords(const SkPoint points[], size_t first_point, size_t amount,
	GrGLfloat coords[]) {
	for (size_t i = 0; i < amount; ++i) {
	coords[i * 2] = SkScalarToFloat(points[first_point + i].fX);
	coords[i * 2 + 1] = SkScalarToFloat(points[first_point + i].fY);
	}
	}
	}

	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));
	}
	}

	GrGLPath::GrGLPath(GrGLGpu* gpu, const SkPath& origSkPath, const GrStrokeInfo& origStroke)
	: INHERITED(gpu, origSkPath, origStroke),
	fPathID(gpu->glPathRendering()->genPaths(1)) {
	// Convert a dashing to either a stroke or a fill.
	const SkPath* skPath = &origSkPath;
	SkTLazy<SkPath> tmpPath;
	const GrStrokeInfo* stroke = &origStroke;
	GrStrokeInfo tmpStroke(SkStrokeRec::kFill_InitStyle);

	if (stroke->isDashed()) {
	if (stroke->applyDashToPath(tmpPath.init(), &tmpStroke, *skPath)) {
	skPath = tmpPath.get();
	stroke = &tmpStroke;
	}
	}

	InitPathObject(gpu, fPathID, skPath, stroke);

	fShouldStroke = stroke->needToApply();
	fShouldFill = stroke->isFillStyle() \|\|
	stroke->getStyle() == SkStrokeRec::kStrokeAndFill_Style;

	if (fShouldStroke) {
	// FIXME: try to account for stroking, without rasterizing the stroke.
	fBounds.outset(stroke->getWidth(), stroke->getWidth());
	}

	this->registerWithCache();
	}

	void GrGLPath::onRelease() {
	if (0 != fPathID && !this->isWrapped()) {
	static_cast<GrGLGpu*>(this->getGpu())->glPathRendering()->deletePaths(fPathID, 1);
	fPathID = 0;
	}

	INHERITED::onRelease();
	}

	void GrGLPath::onAbandon() {
	fPathID = 0;

	INHERITED::onAbandon();
	}