blob: d907e86559fc1bee0f520736f18f23e54974d11a [file] [log] [blame]
/*
* 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);
}