src/gpu/gl/GrGLPathRendering.cpp - platform/external/skia - Gitiles

 /*
  * 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 "gl/GrGLPathRendering.h"
 #include "gl/GrGLUtil.h"
 #include "gl/GrGLGpu.h"

 #include "GrGLPath.h"
 #include "GrGLPathRange.h"
 #include "GrGLPathRendering.h"

 #include "SkStream.h"
 #include "SkTypeface.h"

 #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
 #define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->gpu()->glInterface(), RET, X)

 // Number of paths to allocate per glGenPaths call. The call can be overly slow on command buffer GL
 // implementation. The call has a result value, and thus waiting for the call completion is needed.
 static const GrGLsizei kPathIDPreallocationAmount = 65536;

 static const GrGLenum gIndexType2GLType[] = {
     GR_GL_UNSIGNED_BYTE,
     GR_GL_UNSIGNED_SHORT,
     GR_GL_UNSIGNED_INT
 };

 GR_STATIC_ASSERT(0 == GrPathRange::kU8_PathIndexType);
 GR_STATIC_ASSERT(1 == GrPathRange::kU16_PathIndexType);
 GR_STATIC_ASSERT(2 == GrPathRange::kU32_PathIndexType);
 GR_STATIC_ASSERT(GrPathRange::kU32_PathIndexType == GrPathRange::kLast_PathIndexType);

 static const GrGLenum gXformType2GLType[] = {
     GR_GL_NONE,
     GR_GL_TRANSLATE_X,
     GR_GL_TRANSLATE_Y,
     GR_GL_TRANSLATE_2D,
     GR_GL_TRANSPOSE_AFFINE_2D
 };

 GR_STATIC_ASSERT(0 == GrPathRendering::kNone_PathTransformType);
 GR_STATIC_ASSERT(1 == GrPathRendering::kTranslateX_PathTransformType);
 GR_STATIC_ASSERT(2 == GrPathRendering::kTranslateY_PathTransformType);
 GR_STATIC_ASSERT(3 == GrPathRendering::kTranslate_PathTransformType);
 GR_STATIC_ASSERT(4 == GrPathRendering::kAffine_PathTransformType);
 GR_STATIC_ASSERT(GrPathRendering::kAffine_PathTransformType == GrPathRendering::kLast_PathTransformType);

 #ifdef SK_DEBUG
 static const GrGLenum gXformType2ComponentCount[] = {
     0,
     1,
     1,
     2,
     6
 };

 static void verify_floats(const float* floats, int count) {
     for (int i = 0; i < count; ++i) {
         SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
     }
 }
 #endif

 static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
     switch (op) {
         default:
             SK_ABORT("Unexpected path fill.");
             /* fallthrough */;
         case GrStencilOp::kIncWrap:
             return GR_GL_COUNT_UP;
         case GrStencilOp::kInvert:
             return GR_GL_INVERT;
     }
 }

 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu)
     , fPreallocatedPathCount(0) {
     const GrGLInterface* glInterface = gpu->glInterface();
     fCaps.bindFragmentInputSupport = (bool)glInterface->fFunctions.fBindFragmentInputLocation;
 }

 GrGLPathRendering::~GrGLPathRendering() {
     if (fPreallocatedPathCount > 0) {
         this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
     }
 }

 void GrGLPathRendering::disconnect(GrGpu::DisconnectType type) {
     if (GrGpu::DisconnectType::kCleanup == type) {
         this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
     };
     fPreallocatedPathCount = 0;
 }

 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));

     fHWPathStencilSettings.invalidate();
 }

 sk_sp<GrPath> GrGLPathRendering::createPath(const SkPath& inPath, const GrStyle& style) {
     return sk_make_sp<GrGLPath>(this->gpu(), inPath, style);
 }

 sk_sp<GrPathRange> GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
                                                       const GrStyle& style) {
     return sk_make_sp<GrGLPathRange>(this->gpu(), pathGenerator, style);
 }

 void GrGLPathRendering::onStencilPath(const StencilPathArgs& args, const GrPath* path) {
     GrGLGpu* gpu = this->gpu();
     SkASSERT(gpu->caps()->shaderCaps()->pathRenderingSupport());
     gpu->flushColorWrite(false);

     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(args.fProxy->priv().peekRenderTarget());
     SkISize size = SkISize::Make(rt->width(), rt->height());
     this->setProjectionMatrix(*args.fViewMatrix, size, args.fProxy->origin());
     gpu->flushScissor(*args.fScissor, rt->getViewport(), args.fProxy->origin());
     gpu->flushHWAAState(rt, args.fUseHWAA, true);
     gpu->flushRenderTarget(rt, nullptr);

     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);

     this->flushPathStencilSettings(*args.fStencil);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());

     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
     GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

     if (glPath->shouldFill()) {
         GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
     }
     if (glPath->shouldStroke()) {
         GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
     }
 }

 void GrGLPathRendering::onDrawPath(const GrPipeline& pipeline,
                                    const GrPrimitiveProcessor& primProc,
                                    const GrStencilSettings& stencilPassSettings,
                                    const GrPath* path) {
     if (!this->gpu()->flushGLState(pipeline, primProc, false)) {
         return;
     }
     const GrGLPath* glPath = static_cast<const GrGLPath*>(path);

     this->flushPathStencilSettings(stencilPassSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());

     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
     GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

     if (glPath->shouldStroke()) {
         if (glPath->shouldFill()) {
             GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
         }
         GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
                                            GR_GL_BOUNDING_BOX));
     } else {
         GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
                                          GR_GL_BOUNDING_BOX));
     }
 }

 void GrGLPathRendering::onDrawPaths(const GrPipeline& pipeline,
                                     const GrPrimitiveProcessor& primProc,
                                     const GrStencilSettings& stencilPassSettings,
                                     const GrPathRange* pathRange, const void* indices,
                                     PathIndexType indexType, const float transformValues[],
                                     PathTransformType transformType, int count) {
     SkDEBUGCODE(verify_floats(transformValues, gXformType2ComponentCount[transformType] * count));

     if (!this->gpu()->flushGLState(pipeline, primProc, false)) {
         return;
     }
     this->flushPathStencilSettings(stencilPassSettings);
     SkASSERT(!fHWPathStencilSettings.isTwoSided());


     const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);

     GrGLenum fillMode =
         gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
     GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

     if (glPathRange->shouldStroke()) {
         if (glPathRange->shouldFill()) {
             GL_CALL(StencilFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, gXformType2GLType[transformType],
                             transformValues));
         }
         GL_CALL(StencilThenCoverStrokePathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues));
     } else {
         GL_CALL(StencilThenCoverFillPathInstanced(
                             count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
                             fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
                             gXformType2GLType[transformType], transformValues));
     }
 }

 void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
                                                              GrGLenum genMode, GrGLint components,
                                                              const SkMatrix& matrix) {
     float coefficients[3 * 3];
     SkASSERT(components >= 1 && components <= 3);

     coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
     coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
     coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);

     if (components >= 2) {
         coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
         coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
         coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
     }

     if (components >= 3) {
         coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
         coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
         coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
     }
     SkDEBUGCODE(verify_floats(coefficients, components * 3));

     GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coefficients));
 }

 void GrGLPathRendering::setProjectionMatrix(const SkMatrix& matrix,
                                             const SkISize& renderTargetSize,
                                             GrSurfaceOrigin renderTargetOrigin) {

     SkASSERT(this->gpu()->glCaps().shaderCaps()->pathRenderingSupport());

     if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin &&
         renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize &&
         matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
         return;
     }

     fHWProjectionMatrixState.fViewMatrix = matrix;
     fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
     fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;

     float glMatrix[4 * 4];
     fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
     SkDEBUGCODE(verify_floats(glMatrix, SK_ARRAY_COUNT(glMatrix)));
     GL_CALL(MatrixLoadf(GR_GL_PATH_PROJECTION, glMatrix));
 }

 GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
     SkASSERT(range > 0);
     GrGLuint firstID;
     if (fPreallocatedPathCount >= range) {
         firstID = fFirstPreallocatedPathID;
         fPreallocatedPathCount -= range;
         fFirstPreallocatedPathID += range;
         return firstID;
     }
     // Allocate range + the amount to fill up preallocation amount. If succeed, either join with
     // the existing preallocation range or delete the existing and use the new (potentially partial)
     // preallocation range.
     GrGLsizei allocAmount = range + (kPathIDPreallocationAmount - fPreallocatedPathCount);
     if (allocAmount >= range) {
         GL_CALL_RET(firstID, GenPaths(allocAmount));

         if (firstID != 0) {
             if (fPreallocatedPathCount > 0 &&
                 firstID == fFirstPreallocatedPathID + fPreallocatedPathCount) {
                 firstID = fFirstPreallocatedPathID;
                 fPreallocatedPathCount += allocAmount - range;
                 fFirstPreallocatedPathID += range;
                 return firstID;
             }

             if (allocAmount > range) {
                 if (fPreallocatedPathCount > 0) {
                     this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
                 }
                 fFirstPreallocatedPathID = firstID + range;
                 fPreallocatedPathCount = allocAmount - range;
             }
             // Special case: if allocAmount == range, we have full preallocated range.
             return firstID;
         }
     }
     // Failed to allocate with preallocation. Remove existing preallocation and try to allocate just
     // the range.
     if (fPreallocatedPathCount > 0) {
         this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
         fPreallocatedPathCount = 0;
     }

     GL_CALL_RET(firstID, GenPaths(range));
     if (firstID == 0) {
         SkDebugf("Warning: Failed to allocate path\n");
     }
     return firstID;
 }

 void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
     GL_CALL(DeletePaths(path, range));
 }

 void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
     if (fHWPathStencilSettings != stencilSettings) {
         SkASSERT(stencilSettings.isValid());
         // Just the func, ref, and mask is set here. The op and write mask are params to the call
         // that draws the path to the SB (glStencilFillPath)
         uint16_t ref = stencilSettings.front().fRef;
         GrStencilTest test = stencilSettings.front().fTest;
         uint16_t testMask = stencilSettings.front().fTestMask;

         if (!fHWPathStencilSettings.isValid() ||
             ref != fHWPathStencilSettings.front().fRef ||
             test != fHWPathStencilSettings.front().fTest ||
             testMask != fHWPathStencilSettings.front().fTestMask) {
             GL_CALL(PathStencilFunc(GrToGLStencilFunc(test), ref, testMask));
         }
         fHWPathStencilSettings = stencilSettings;
     }
 }

 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }
	/*
	* 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 "gl/GrGLPathRendering.h"
	#include "gl/GrGLUtil.h"
	#include "gl/GrGLGpu.h"

	#include "GrGLPath.h"
	#include "GrGLPathRange.h"
	#include "GrGLPathRendering.h"

	#include "SkStream.h"
	#include "SkTypeface.h"

	#define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X)
	#define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->gpu()->glInterface(), RET, X)

	// Number of paths to allocate per glGenPaths call. The call can be overly slow on command buffer GL
	// implementation. The call has a result value, and thus waiting for the call completion is needed.
	static const GrGLsizei kPathIDPreallocationAmount = 65536;

	static const GrGLenum gIndexType2GLType[] = {
	GR_GL_UNSIGNED_BYTE,
	GR_GL_UNSIGNED_SHORT,
	GR_GL_UNSIGNED_INT
	};

	GR_STATIC_ASSERT(0 == GrPathRange::kU8_PathIndexType);
	GR_STATIC_ASSERT(1 == GrPathRange::kU16_PathIndexType);
	GR_STATIC_ASSERT(2 == GrPathRange::kU32_PathIndexType);
	GR_STATIC_ASSERT(GrPathRange::kU32_PathIndexType == GrPathRange::kLast_PathIndexType);

	static const GrGLenum gXformType2GLType[] = {
	GR_GL_NONE,
	GR_GL_TRANSLATE_X,
	GR_GL_TRANSLATE_Y,
	GR_GL_TRANSLATE_2D,
	GR_GL_TRANSPOSE_AFFINE_2D
	};

	GR_STATIC_ASSERT(0 == GrPathRendering::kNone_PathTransformType);
	GR_STATIC_ASSERT(1 == GrPathRendering::kTranslateX_PathTransformType);
	GR_STATIC_ASSERT(2 == GrPathRendering::kTranslateY_PathTransformType);
	GR_STATIC_ASSERT(3 == GrPathRendering::kTranslate_PathTransformType);
	GR_STATIC_ASSERT(4 == GrPathRendering::kAffine_PathTransformType);
	GR_STATIC_ASSERT(GrPathRendering::kAffine_PathTransformType == GrPathRendering::kLast_PathTransformType);

	#ifdef SK_DEBUG
	static const GrGLenum gXformType2ComponentCount[] = {
	0,
	1,
	1,
	2,
	6
	};

	static void verify_floats(const float* floats, int count) {
	for (int i = 0; i < count; ++i) {
	SkASSERT(!SkScalarIsNaN(SkFloatToScalar(floats[i])));
	}
	}
	#endif

	static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
	switch (op) {
	default:
	SK_ABORT("Unexpected path fill.");
	/* fallthrough */;
	case GrStencilOp::kIncWrap:
	return GR_GL_COUNT_UP;
	case GrStencilOp::kInvert:
	return GR_GL_INVERT;
	}
	}

	GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
	: GrPathRendering(gpu)
	, fPreallocatedPathCount(0) {
	const GrGLInterface* glInterface = gpu->glInterface();
	fCaps.bindFragmentInputSupport = (bool)glInterface->fFunctions.fBindFragmentInputLocation;
	}

	GrGLPathRendering::~GrGLPathRendering() {
	if (fPreallocatedPathCount > 0) {
	this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
	}
	}

	void GrGLPathRendering::disconnect(GrGpu::DisconnectType type) {
	if (GrGpu::DisconnectType::kCleanup == type) {
	this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
	};
	fPreallocatedPathCount = 0;
	}

	void GrGLPathRendering::resetContext() {
	fHWProjectionMatrixState.invalidate();
	// we don't use the model view matrix.
	GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));

	fHWPathStencilSettings.invalidate();
	}

	sk_sp<GrPath> GrGLPathRendering::createPath(const SkPath& inPath, const GrStyle& style) {
	return sk_make_sp<GrGLPath>(this->gpu(), inPath, style);
	}

	sk_sp<GrPathRange> GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
	const GrStyle& style) {
	return sk_make_sp<GrGLPathRange>(this->gpu(), pathGenerator, style);
	}

	void GrGLPathRendering::onStencilPath(const StencilPathArgs& args, const GrPath* path) {
	GrGLGpu* gpu = this->gpu();
	SkASSERT(gpu->caps()->shaderCaps()->pathRenderingSupport());
	gpu->flushColorWrite(false);

	GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(args.fProxy->priv().peekRenderTarget());
	SkISize size = SkISize::Make(rt->width(), rt->height());
	this->setProjectionMatrix(*args.fViewMatrix, size, args.fProxy->origin());
	gpu->flushScissor(*args.fScissor, rt->getViewport(), args.fProxy->origin());
	gpu->flushHWAAState(rt, args.fUseHWAA, true);
	gpu->flushRenderTarget(rt, nullptr);

	const GrGLPath* glPath = static_cast<const GrGLPath*>(path);

	this->flushPathStencilSettings(*args.fStencil);
	SkASSERT(!fHWPathStencilSettings.isTwoSided());

	GrGLenum fillMode =
	gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
	GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

	if (glPath->shouldFill()) {
	GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
	}
	if (glPath->shouldStroke()) {
	GL_CALL(StencilStrokePath(glPath->pathID(), 0xffff, writeMask));
	}
	}

	void GrGLPathRendering::onDrawPath(const GrPipeline& pipeline,
	const GrPrimitiveProcessor& primProc,
	const GrStencilSettings& stencilPassSettings,
	const GrPath* path) {
	if (!this->gpu()->flushGLState(pipeline, primProc, false)) {
	return;
	}
	const GrGLPath* glPath = static_cast<const GrGLPath*>(path);

	this->flushPathStencilSettings(stencilPassSettings);
	SkASSERT(!fHWPathStencilSettings.isTwoSided());

	GrGLenum fillMode =
	gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
	GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

	if (glPath->shouldStroke()) {
	if (glPath->shouldFill()) {
	GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
	}
	GL_CALL(StencilThenCoverStrokePath(glPath->pathID(), 0xffff, writeMask,
	GR_GL_BOUNDING_BOX));
	} else {
	GL_CALL(StencilThenCoverFillPath(glPath->pathID(), fillMode, writeMask,
	GR_GL_BOUNDING_BOX));
	}
	}

	void GrGLPathRendering::onDrawPaths(const GrPipeline& pipeline,
	const GrPrimitiveProcessor& primProc,
	const GrStencilSettings& stencilPassSettings,
	const GrPathRange* pathRange, const void* indices,
	PathIndexType indexType, const float transformValues[],
	PathTransformType transformType, int count) {
	SkDEBUGCODE(verify_floats(transformValues, gXformType2ComponentCount[transformType] * count));

	if (!this->gpu()->flushGLState(pipeline, primProc, false)) {
	return;
	}
	this->flushPathStencilSettings(stencilPassSettings);
	SkASSERT(!fHWPathStencilSettings.isTwoSided());


	const GrGLPathRange* glPathRange = static_cast<const GrGLPathRange*>(pathRange);

	GrGLenum fillMode =
	gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.front().fPassOp);
	GrGLint writeMask = fHWPathStencilSettings.front().fWriteMask;

	if (glPathRange->shouldStroke()) {
	if (glPathRange->shouldFill()) {
	GL_CALL(StencilFillPathInstanced(
	count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
	fillMode, writeMask, gXformType2GLType[transformType],
	transformValues));
	}
	GL_CALL(StencilThenCoverStrokePathInstanced(
	count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
	0xffff, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
	gXformType2GLType[transformType], transformValues));
	} else {
	GL_CALL(StencilThenCoverFillPathInstanced(
	count, gIndexType2GLType[indexType], indices, glPathRange->basePathID(),
	fillMode, writeMask, GR_GL_BOUNDING_BOX_OF_BOUNDING_BOXES,
	gXformType2GLType[transformType], transformValues));
	}
	}

	void GrGLPathRendering::setProgramPathFragmentInputTransform(GrGLuint program, GrGLint location,
	GrGLenum genMode, GrGLint components,
	const SkMatrix& matrix) {
	float coefficients[3 * 3];
	SkASSERT(components >= 1 && components <= 3);

	coefficients[0] = SkScalarToFloat(matrix[SkMatrix::kMScaleX]);
	coefficients[1] = SkScalarToFloat(matrix[SkMatrix::kMSkewX]);
	coefficients[2] = SkScalarToFloat(matrix[SkMatrix::kMTransX]);

	if (components >= 2) {
	coefficients[3] = SkScalarToFloat(matrix[SkMatrix::kMSkewY]);
	coefficients[4] = SkScalarToFloat(matrix[SkMatrix::kMScaleY]);
	coefficients[5] = SkScalarToFloat(matrix[SkMatrix::kMTransY]);
	}

	if (components >= 3) {
	coefficients[6] = SkScalarToFloat(matrix[SkMatrix::kMPersp0]);
	coefficients[7] = SkScalarToFloat(matrix[SkMatrix::kMPersp1]);
	coefficients[8] = SkScalarToFloat(matrix[SkMatrix::kMPersp2]);
	}
	SkDEBUGCODE(verify_floats(coefficients, components * 3));

	GL_CALL(ProgramPathFragmentInputGen(program, location, genMode, components, coefficients));
	}

	void GrGLPathRendering::setProjectionMatrix(const SkMatrix& matrix,
	const SkISize& renderTargetSize,
	GrSurfaceOrigin renderTargetOrigin) {

	SkASSERT(this->gpu()->glCaps().shaderCaps()->pathRenderingSupport());

	if (renderTargetOrigin == fHWProjectionMatrixState.fRenderTargetOrigin &&
	renderTargetSize == fHWProjectionMatrixState.fRenderTargetSize &&
	matrix.cheapEqualTo(fHWProjectionMatrixState.fViewMatrix)) {
	return;
	}

	fHWProjectionMatrixState.fViewMatrix = matrix;
	fHWProjectionMatrixState.fRenderTargetSize = renderTargetSize;
	fHWProjectionMatrixState.fRenderTargetOrigin = renderTargetOrigin;

	float glMatrix[4 * 4];
	fHWProjectionMatrixState.getRTAdjustedGLMatrix<4>(glMatrix);
	SkDEBUGCODE(verify_floats(glMatrix, SK_ARRAY_COUNT(glMatrix)));
	GL_CALL(MatrixLoadf(GR_GL_PATH_PROJECTION, glMatrix));
	}

	GrGLuint GrGLPathRendering::genPaths(GrGLsizei range) {
	SkASSERT(range > 0);
	GrGLuint firstID;
	if (fPreallocatedPathCount >= range) {
	firstID = fFirstPreallocatedPathID;
	fPreallocatedPathCount -= range;
	fFirstPreallocatedPathID += range;
	return firstID;
	}
	// Allocate range + the amount to fill up preallocation amount. If succeed, either join with
	// the existing preallocation range or delete the existing and use the new (potentially partial)
	// preallocation range.
	GrGLsizei allocAmount = range + (kPathIDPreallocationAmount - fPreallocatedPathCount);
	if (allocAmount >= range) {
	GL_CALL_RET(firstID, GenPaths(allocAmount));

	if (firstID != 0) {
	if (fPreallocatedPathCount > 0 &&
	firstID == fFirstPreallocatedPathID + fPreallocatedPathCount) {
	firstID = fFirstPreallocatedPathID;
	fPreallocatedPathCount += allocAmount - range;
	fFirstPreallocatedPathID += range;
	return firstID;
	}

	if (allocAmount > range) {
	if (fPreallocatedPathCount > 0) {
	this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
	}
	fFirstPreallocatedPathID = firstID + range;
	fPreallocatedPathCount = allocAmount - range;
	}
	// Special case: if allocAmount == range, we have full preallocated range.
	return firstID;
	}
	}
	// Failed to allocate with preallocation. Remove existing preallocation and try to allocate just
	// the range.
	if (fPreallocatedPathCount > 0) {
	this->deletePaths(fFirstPreallocatedPathID, fPreallocatedPathCount);
	fPreallocatedPathCount = 0;
	}

	GL_CALL_RET(firstID, GenPaths(range));
	if (firstID == 0) {
	SkDebugf("Warning: Failed to allocate path\n");
	}
	return firstID;
	}

	void GrGLPathRendering::deletePaths(GrGLuint path, GrGLsizei range) {
	GL_CALL(DeletePaths(path, range));
	}

	void GrGLPathRendering::flushPathStencilSettings(const GrStencilSettings& stencilSettings) {
	if (fHWPathStencilSettings != stencilSettings) {
	SkASSERT(stencilSettings.isValid());
	// Just the func, ref, and mask is set here. The op and write mask are params to the call
	// that draws the path to the SB (glStencilFillPath)
	uint16_t ref = stencilSettings.front().fRef;
	GrStencilTest test = stencilSettings.front().fTest;
	uint16_t testMask = stencilSettings.front().fTestMask;

	if (!fHWPathStencilSettings.isValid() \|\|
	ref != fHWPathStencilSettings.front().fRef \|\|
	test != fHWPathStencilSettings.front().fTest \|\|
	testMask != fHWPathStencilSettings.front().fTestMask) {
	GL_CALL(PathStencilFunc(GrToGLStencilFunc(test), ref, testMask));
	}
	fHWPathStencilSettings = stencilSettings;
	}
	}

	inline GrGLGpu* GrGLPathRendering::gpu() {
	return static_cast<GrGLGpu*>(fGpu);
	}