| /* |
| * Copyright 2013 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "GrBezierEffect.h" |
| #include "GrShaderCaps.h" |
| #include "glsl/GrGLSLFragmentShaderBuilder.h" |
| #include "glsl/GrGLSLGeometryProcessor.h" |
| #include "glsl/GrGLSLProgramDataManager.h" |
| #include "glsl/GrGLSLUniformHandler.h" |
| #include "glsl/GrGLSLUtil.h" |
| #include "glsl/GrGLSLVarying.h" |
| #include "glsl/GrGLSLVertexShaderBuilder.h" |
| |
| class GrGLConicEffect : public GrGLSLGeometryProcessor { |
| public: |
| GrGLConicEffect(const GrGeometryProcessor&); |
| |
| void onEmitCode(EmitArgs&, GrGPArgs*) override; |
| |
| static inline void GenKey(const GrGeometryProcessor&, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder*); |
| |
| void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, |
| FPCoordTransformIter&& transformIter) override { |
| const GrConicEffect& ce = primProc.cast<GrConicEffect>(); |
| |
| if (!ce.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(ce.viewMatrix())) { |
| fViewMatrix = ce.viewMatrix(); |
| float viewMatrix[3 * 3]; |
| GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix); |
| pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); |
| } |
| |
| if (ce.color() != fColor) { |
| float c[4]; |
| GrColorToRGBAFloat(ce.color(), c); |
| pdman.set4fv(fColorUniform, 1, c); |
| fColor = ce.color(); |
| } |
| |
| if (ce.coverageScale() != 0xff && ce.coverageScale() != fCoverageScale) { |
| pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(ce.coverageScale())); |
| fCoverageScale = ce.coverageScale(); |
| } |
| this->setTransformDataHelper(ce.localMatrix(), pdman, &transformIter); |
| } |
| |
| private: |
| SkMatrix fViewMatrix; |
| GrColor fColor; |
| uint8_t fCoverageScale; |
| GrPrimitiveEdgeType fEdgeType; |
| UniformHandle fColorUniform; |
| UniformHandle fCoverageScaleUniform; |
| UniformHandle fViewMatrixUniform; |
| |
| typedef GrGLSLGeometryProcessor INHERITED; |
| }; |
| |
| GrGLConicEffect::GrGLConicEffect(const GrGeometryProcessor& processor) |
| : fViewMatrix(SkMatrix::InvalidMatrix()), fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { |
| const GrConicEffect& ce = processor.cast<GrConicEffect>(); |
| fEdgeType = ce.getEdgeType(); |
| } |
| |
| void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
| GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder; |
| const GrConicEffect& gp = args.fGP.cast<GrConicEffect>(); |
| GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; |
| GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
| |
| // emit attributes |
| varyingHandler->emitAttributes(gp); |
| |
| GrGLSLVertToFrag v(kVec4f_GrSLType); |
| varyingHandler->addVarying("ConicCoeffs", &v, kHigh_GrSLPrecision); |
| vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName); |
| |
| GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder; |
| // Setup pass through color |
| this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); |
| |
| // Setup position |
| this->setupPosition(vertBuilder, |
| uniformHandler, |
| gpArgs, |
| gp.inPosition()->fName, |
| gp.viewMatrix(), |
| &fViewMatrixUniform); |
| |
| // emit transforms with position |
| this->emitTransforms(vertBuilder, |
| varyingHandler, |
| uniformHandler, |
| gpArgs->fPositionVar, |
| gp.inPosition()->fName, |
| gp.localMatrix(), |
| args.fFPCoordTransformHandler); |
| |
| // TODO: this precision check should actually be a check on the number of bits |
| // high and medium provide and the selection of the lowest level that suffices. |
| // Additionally we should assert that the upstream code only lets us get here if |
| // either high or medium provides the required number of bits. |
| GrSLPrecision precision = kHigh_GrSLPrecision; |
| const GrShaderCaps::PrecisionInfo& highP = args.fShaderCaps->getFloatShaderPrecisionInfo( |
| kFragment_GrShaderType, |
| kHigh_GrSLPrecision); |
| if (!highP.supported()) { |
| precision = kMedium_GrSLPrecision; |
| } |
| |
| GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, precision); |
| GrShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, precision); |
| GrShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, precision); |
| GrShaderVar dfdx("dfdx", kFloat_GrSLType, 0, precision); |
| GrShaderVar dfdy("dfdy", kFloat_GrSLType, 0, precision); |
| GrShaderVar gF("gF", kVec2f_GrSLType, 0, precision); |
| GrShaderVar gFM("gFM", kFloat_GrSLType, 0, precision); |
| GrShaderVar func("func", kFloat_GrSLType, 0, precision); |
| |
| fragBuilder->declAppend(edgeAlpha); |
| fragBuilder->declAppend(dklmdx); |
| fragBuilder->declAppend(dklmdy); |
| fragBuilder->declAppend(dfdx); |
| fragBuilder->declAppend(dfdy); |
| fragBuilder->declAppend(gF); |
| fragBuilder->declAppend(gFM); |
| fragBuilder->declAppend(func); |
| |
| switch (fEdgeType) { |
| case kHairlineAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;", |
| dfdx.c_str(), |
| v.fsIn(), dklmdx.c_str(), |
| v.fsIn(), dklmdx.c_str(), |
| v.fsIn(), dklmdx.c_str()); |
| fragBuilder->codeAppendf("%s = 2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;", |
| dfdy.c_str(), |
| v.fsIn(), dklmdy.c_str(), |
| v.fsIn(), dklmdy.c_str(), |
| v.fsIn(), dklmdy.c_str()); |
| fragBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); |
| fragBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", |
| gFM.c_str(), gF.c_str(), gF.c_str()); |
| fragBuilder->codeAppendf("%s = %s.x*%s.x - %s.y*%s.z;", |
| func.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str()); |
| fragBuilder->codeAppendf("%s = %s / %s;", |
| edgeAlpha.c_str(), func.c_str(), gFM.c_str()); |
| fragBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);", |
| edgeAlpha.c_str(), edgeAlpha.c_str()); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);"); |
| break; |
| } |
| case kFillAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), v.fsIn()); |
| fragBuilder->codeAppendf("%s =" |
| "2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;", |
| dfdx.c_str(), |
| v.fsIn(), dklmdx.c_str(), |
| v.fsIn(), dklmdx.c_str(), |
| v.fsIn(), dklmdx.c_str()); |
| fragBuilder->codeAppendf("%s =" |
| "2.0 * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;", |
| dfdy.c_str(), |
| v.fsIn(), dklmdy.c_str(), |
| v.fsIn(), dklmdy.c_str(), |
| v.fsIn(), dklmdy.c_str()); |
| fragBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str()); |
| fragBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", |
| gFM.c_str(), gF.c_str(), gF.c_str()); |
| fragBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", |
| func.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = %s / %s;", |
| edgeAlpha.c_str(), func.c_str(), gFM.c_str()); |
| fragBuilder->codeAppendf("%s = clamp(0.5 - %s, 0.0, 1.0);", |
| edgeAlpha.c_str(), edgeAlpha.c_str()); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);"); |
| break; |
| } |
| case kFillBW_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = %s.x * %s.x - %s.y * %s.z;", |
| edgeAlpha.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = float(%s < 0.0);", |
| edgeAlpha.c_str(), edgeAlpha.c_str()); |
| break; |
| } |
| default: |
| SkFAIL("Shouldn't get here"); |
| } |
| |
| // TODO should we really be doing this? |
| if (gp.coverageScale() != 0xff) { |
| const char* coverageScale; |
| fCoverageScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, |
| kFloat_GrSLType, |
| kHigh_GrSLPrecision, |
| "Coverage", |
| &coverageScale); |
| fragBuilder->codeAppendf("%s = vec4(%s * %s);", |
| args.fOutputCoverage, coverageScale, edgeAlpha.c_str()); |
| } else { |
| fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); |
| } |
| } |
| |
| void GrGLConicEffect::GenKey(const GrGeometryProcessor& gp, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder* b) { |
| const GrConicEffect& ce = gp.cast<GrConicEffect>(); |
| uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
| key |= 0xff != ce.coverageScale() ? 0x8 : 0x0; |
| key |= ce.usesLocalCoords() && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; |
| key |= ComputePosKey(ce.viewMatrix()) << 5; |
| b->add32(key); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GrConicEffect::~GrConicEffect() {} |
| |
| void GrConicEffect::getGLSLProcessorKey(const GrShaderCaps& caps, |
| GrProcessorKeyBuilder* b) const { |
| GrGLConicEffect::GenKey(*this, caps, b); |
| } |
| |
| GrGLSLPrimitiveProcessor* GrConicEffect::createGLSLInstance(const GrShaderCaps&) const { |
| return new GrGLConicEffect(*this); |
| } |
| |
| GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage, |
| GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix, |
| bool usesLocalCoords) |
| : fColor(color) |
| , fViewMatrix(viewMatrix) |
| , fLocalMatrix(viewMatrix) |
| , fUsesLocalCoords(usesLocalCoords) |
| , fCoverageScale(coverage) |
| , fEdgeType(edgeType) { |
| this->initClassID<GrConicEffect>(); |
| fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType, |
| kHigh_GrSLPrecision); |
| fInConicCoeffs = &this->addVertexAttrib("inConicCoeffs", kVec4f_GrVertexAttribType); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrConicEffect); |
| |
| #if GR_TEST_UTILS |
| sk_sp<GrGeometryProcessor> GrConicEffect::TestCreate(GrProcessorTestData* d) { |
| sk_sp<GrGeometryProcessor> gp; |
| do { |
| GrPrimitiveEdgeType edgeType = |
| static_cast<GrPrimitiveEdgeType>( |
| d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt)); |
| gp = GrConicEffect::Make(GrRandomColor(d->fRandom), GrTest::TestMatrix(d->fRandom), |
| edgeType, *d->caps(), GrTest::TestMatrix(d->fRandom), |
| d->fRandom->nextBool()); |
| } while (nullptr == gp); |
| return gp; |
| } |
| #endif |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Quad |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| class GrGLQuadEffect : public GrGLSLGeometryProcessor { |
| public: |
| GrGLQuadEffect(const GrGeometryProcessor&); |
| |
| void onEmitCode(EmitArgs&, GrGPArgs*) override; |
| |
| static inline void GenKey(const GrGeometryProcessor&, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder*); |
| |
| void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, |
| FPCoordTransformIter&& transformIter) override { |
| const GrQuadEffect& qe = primProc.cast<GrQuadEffect>(); |
| |
| if (!qe.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(qe.viewMatrix())) { |
| fViewMatrix = qe.viewMatrix(); |
| float viewMatrix[3 * 3]; |
| GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix); |
| pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); |
| } |
| |
| if (qe.color() != fColor) { |
| float c[4]; |
| GrColorToRGBAFloat(qe.color(), c); |
| pdman.set4fv(fColorUniform, 1, c); |
| fColor = qe.color(); |
| } |
| |
| if (qe.coverageScale() != 0xff && qe.coverageScale() != fCoverageScale) { |
| pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(qe.coverageScale())); |
| fCoverageScale = qe.coverageScale(); |
| } |
| this->setTransformDataHelper(qe.localMatrix(), pdman, &transformIter); |
| } |
| |
| private: |
| SkMatrix fViewMatrix; |
| GrColor fColor; |
| uint8_t fCoverageScale; |
| GrPrimitiveEdgeType fEdgeType; |
| UniformHandle fColorUniform; |
| UniformHandle fCoverageScaleUniform; |
| UniformHandle fViewMatrixUniform; |
| |
| typedef GrGLSLGeometryProcessor INHERITED; |
| }; |
| |
| GrGLQuadEffect::GrGLQuadEffect(const GrGeometryProcessor& processor) |
| : fViewMatrix(SkMatrix::InvalidMatrix()), fColor(GrColor_ILLEGAL), fCoverageScale(0xff) { |
| const GrQuadEffect& ce = processor.cast<GrQuadEffect>(); |
| fEdgeType = ce.getEdgeType(); |
| } |
| |
| void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
| GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder; |
| const GrQuadEffect& gp = args.fGP.cast<GrQuadEffect>(); |
| GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; |
| GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
| |
| // emit attributes |
| varyingHandler->emitAttributes(gp); |
| |
| GrGLSLVertToFrag v(kVec4f_GrSLType); |
| varyingHandler->addVarying("HairQuadEdge", &v); |
| vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName); |
| |
| GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder; |
| // Setup pass through color |
| this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); |
| |
| // Setup position |
| this->setupPosition(vertBuilder, |
| uniformHandler, |
| gpArgs, |
| gp.inPosition()->fName, |
| gp.viewMatrix(), |
| &fViewMatrixUniform); |
| |
| // emit transforms with position |
| this->emitTransforms(vertBuilder, |
| varyingHandler, |
| uniformHandler, |
| gpArgs->fPositionVar, |
| gp.inPosition()->fName, |
| gp.localMatrix(), |
| args.fFPCoordTransformHandler); |
| |
| fragBuilder->codeAppendf("float edgeAlpha;"); |
| |
| switch (fEdgeType) { |
| case kHairlineAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); |
| fragBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn()); |
| fragBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y," |
| " 2.0 * %s.x * duvdy.x - duvdy.y);", |
| v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", |
| v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(gF, gF));"); |
| fragBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);"); |
| break; |
| } |
| case kFillAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn()); |
| fragBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn()); |
| fragBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y," |
| " 2.0 * %s.x * duvdy.x - duvdy.y);", |
| v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", |
| v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppend("edgeAlpha = edgeAlpha / sqrt(dot(gF, gF));"); |
| fragBuilder->codeAppend("edgeAlpha = clamp(0.5 - edgeAlpha, 0.0, 1.0);"); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);"); |
| break; |
| } |
| case kFillBW_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", |
| v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); |
| break; |
| } |
| default: |
| SkFAIL("Shouldn't get here"); |
| } |
| |
| if (0xff != gp.coverageScale()) { |
| const char* coverageScale; |
| fCoverageScaleUniform = uniformHandler->addUniform(kFragment_GrShaderFlag, |
| kFloat_GrSLType, |
| kDefault_GrSLPrecision, |
| "Coverage", |
| &coverageScale); |
| fragBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale); |
| } else { |
| fragBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage); |
| } |
| } |
| |
| void GrGLQuadEffect::GenKey(const GrGeometryProcessor& gp, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder* b) { |
| const GrQuadEffect& ce = gp.cast<GrQuadEffect>(); |
| uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
| key |= ce.coverageScale() != 0xff ? 0x8 : 0x0; |
| key |= ce.usesLocalCoords() && ce.localMatrix().hasPerspective() ? 0x10 : 0x0; |
| key |= ComputePosKey(ce.viewMatrix()) << 5; |
| b->add32(key); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GrQuadEffect::~GrQuadEffect() {} |
| |
| void GrQuadEffect::getGLSLProcessorKey(const GrShaderCaps& caps, |
| GrProcessorKeyBuilder* b) const { |
| GrGLQuadEffect::GenKey(*this, caps, b); |
| } |
| |
| GrGLSLPrimitiveProcessor* GrQuadEffect::createGLSLInstance(const GrShaderCaps&) const { |
| return new GrGLQuadEffect(*this); |
| } |
| |
| GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage, |
| GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix, |
| bool usesLocalCoords) |
| : fColor(color) |
| , fViewMatrix(viewMatrix) |
| , fLocalMatrix(localMatrix) |
| , fUsesLocalCoords(usesLocalCoords) |
| , fCoverageScale(coverage) |
| , fEdgeType(edgeType) { |
| this->initClassID<GrQuadEffect>(); |
| fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType, |
| kHigh_GrSLPrecision); |
| fInHairQuadEdge = &this->addVertexAttrib("inHairQuadEdge", kVec4f_GrVertexAttribType); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect); |
| |
| #if GR_TEST_UTILS |
| sk_sp<GrGeometryProcessor> GrQuadEffect::TestCreate(GrProcessorTestData* d) { |
| sk_sp<GrGeometryProcessor> gp; |
| do { |
| GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>( |
| d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt)); |
| gp = GrQuadEffect::Make(GrRandomColor(d->fRandom), GrTest::TestMatrix(d->fRandom), edgeType, |
| *d->caps(), GrTest::TestMatrix(d->fRandom), |
| d->fRandom->nextBool()); |
| } while (nullptr == gp); |
| return gp; |
| } |
| #endif |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // Cubic |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| class GrGLCubicEffect : public GrGLSLGeometryProcessor { |
| public: |
| GrGLCubicEffect(const GrGeometryProcessor&); |
| |
| void onEmitCode(EmitArgs&, GrGPArgs*) override; |
| |
| static inline void GenKey(const GrGeometryProcessor&, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder*); |
| |
| void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, |
| FPCoordTransformIter&& transformIter) override { |
| const GrCubicEffect& ce = primProc.cast<GrCubicEffect>(); |
| |
| if (!ce.viewMatrix().isIdentity() && !fViewMatrix.cheapEqualTo(ce.viewMatrix())) { |
| fViewMatrix = ce.viewMatrix(); |
| float viewMatrix[3 * 3]; |
| GrGLSLGetMatrix<3>(viewMatrix, fViewMatrix); |
| pdman.setMatrix3f(fViewMatrixUniform, viewMatrix); |
| } |
| |
| if (!fDevKLMMatrix.cheapEqualTo(ce.devKLMMatrix())) { |
| fDevKLMMatrix = ce.devKLMMatrix(); |
| float devKLMMatrix[3 * 3]; |
| GrGLSLGetMatrix<3>(devKLMMatrix, fDevKLMMatrix); |
| pdman.setMatrix3f(fDevKLMUniform, devKLMMatrix); |
| } |
| |
| if (ce.color() != fColor) { |
| float c[4]; |
| GrColorToRGBAFloat(ce.color(), c); |
| pdman.set4fv(fColorUniform, 1, c); |
| fColor = ce.color(); |
| } |
| |
| this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter); |
| } |
| |
| private: |
| SkMatrix fViewMatrix; |
| SkMatrix fDevKLMMatrix; |
| GrColor fColor; |
| GrPrimitiveEdgeType fEdgeType; |
| UniformHandle fColorUniform; |
| UniformHandle fViewMatrixUniform; |
| UniformHandle fDevKLMUniform; |
| |
| typedef GrGLSLGeometryProcessor INHERITED; |
| }; |
| |
| GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor) |
| : fViewMatrix(SkMatrix::InvalidMatrix()) |
| , fDevKLMMatrix(SkMatrix::InvalidMatrix()) |
| , fColor(GrColor_ILLEGAL) { |
| const GrCubicEffect& ce = processor.cast<GrCubicEffect>(); |
| fEdgeType = ce.getEdgeType(); |
| } |
| |
| void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { |
| GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder; |
| const GrCubicEffect& gp = args.fGP.cast<GrCubicEffect>(); |
| GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; |
| GrGLSLUniformHandler* uniformHandler = args.fUniformHandler; |
| |
| // emit attributes |
| varyingHandler->emitAttributes(gp); |
| |
| GrGLSLPPFragmentBuilder* fragBuilder = args.fFragBuilder; |
| // Setup pass through color |
| if (!gp.colorIgnored()) { |
| this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); |
| } |
| |
| // Setup position |
| this->setupPosition(vertBuilder, |
| uniformHandler, |
| gpArgs, |
| gp.inPosition()->fName, |
| gp.viewMatrix(), |
| &fViewMatrixUniform); |
| |
| // Setup KLM |
| const char* devkLMMatrixName; |
| fDevKLMUniform = uniformHandler->addUniform(kVertex_GrShaderFlag, kMat33f_GrSLType, |
| kHigh_GrSLPrecision, "KLM", &devkLMMatrixName); |
| GrGLSLVertToFrag v(kVec3f_GrSLType); |
| varyingHandler->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision); |
| vertBuilder->codeAppendf("%s = %s * vec3(%s, 1);", |
| v.vsOut(), devkLMMatrixName, gpArgs->fPositionVar.c_str()); |
| |
| |
| GrGLSLVertToFrag gradCoeffs(kVec4f_GrSLType); |
| if (kFillAA_GrProcessorEdgeType == fEdgeType || kHairlineAA_GrProcessorEdgeType == fEdgeType) { |
| varyingHandler->addVarying("GradCoeffs", &gradCoeffs, kHigh_GrSLPrecision); |
| vertBuilder->codeAppendf("highp float k = %s[0], l = %s[1], m = %s[2];", |
| v.vsOut(), v.vsOut(), v.vsOut()); |
| vertBuilder->codeAppendf("highp vec2 gk = vec2(%s[0][0], %s[1][0]), " |
| "gl = vec2(%s[0][1], %s[1][1]), " |
| "gm = vec2(%s[0][2], %s[1][2]);", |
| devkLMMatrixName, devkLMMatrixName, devkLMMatrixName, |
| devkLMMatrixName, devkLMMatrixName, devkLMMatrixName); |
| vertBuilder->codeAppendf("%s = vec4(3 * k * gk, -m * gl - l * gm);", |
| gradCoeffs.vsOut()); |
| } |
| |
| // emit transforms with position |
| this->emitTransforms(vertBuilder, |
| varyingHandler, |
| uniformHandler, |
| gpArgs->fPositionVar, |
| gp.inPosition()->fName, |
| args.fFPCoordTransformHandler); |
| |
| |
| GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, kHigh_GrSLPrecision); |
| GrShaderVar gF("gF", kVec2f_GrSLType, 0, kHigh_GrSLPrecision); |
| GrShaderVar func("func", kFloat_GrSLType, 0, kHigh_GrSLPrecision); |
| |
| fragBuilder->declAppend(edgeAlpha); |
| fragBuilder->declAppend(gF); |
| fragBuilder->declAppend(func); |
| |
| switch (fEdgeType) { |
| case kHairlineAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = %s.x * %s.xy + %s.zw;", |
| gF.c_str(), v.fsIn(), gradCoeffs.fsIn(), gradCoeffs.fsIn()); |
| fragBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
| func.c_str(), v.fsIn(), v.fsIn(), |
| v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str()); |
| fragBuilder->codeAppendf("%s = %s * inversesqrt(dot(%s, %s));", |
| edgeAlpha.c_str(), func.c_str(), gF.c_str(), gF.c_str()); |
| fragBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);", |
| edgeAlpha.c_str(), edgeAlpha.c_str()); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
| // edgeAlpha.c_str(), edgeAlpha.c_str(), edgeAlpha.c_str(), |
| // edgeAlpha.c_str()); |
| break; |
| } |
| case kFillAA_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = %s.x * %s.xy + %s.zw;", |
| gF.c_str(), v.fsIn(), gradCoeffs.fsIn(), gradCoeffs.fsIn()); |
| fragBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
| func.c_str(), |
| v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = %s * inversesqrt(dot(%s, %s));", |
| edgeAlpha.c_str(), func.c_str(), gF.c_str(), gF.c_str()); |
| fragBuilder->codeAppendf("%s = clamp(0.5 - %s, 0.0, 1.0);", |
| edgeAlpha.c_str(), edgeAlpha.c_str()); |
| // Add line below for smooth cubic ramp |
| // fragBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
| // edgeAlpha.c_str(), edgeAlpha.c_str(), edgeAlpha.c_str(), |
| // edgeAlpha.c_str()); |
| break; |
| } |
| case kFillBW_GrProcessorEdgeType: { |
| fragBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
| edgeAlpha.c_str(), v.fsIn(), v.fsIn(), |
| v.fsIn(), v.fsIn(), v.fsIn()); |
| fragBuilder->codeAppendf("%s = float(%s < 0.0);", edgeAlpha.c_str(), edgeAlpha.c_str()); |
| break; |
| } |
| default: |
| SkFAIL("Shouldn't get here"); |
| } |
| |
| |
| fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_str()); |
| } |
| |
| void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp, |
| const GrShaderCaps&, |
| GrProcessorKeyBuilder* b) { |
| const GrCubicEffect& ce = gp.cast<GrCubicEffect>(); |
| uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; |
| key |= ComputePosKey(ce.viewMatrix()) << 5; |
| b->add32(key); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GrCubicEffect::~GrCubicEffect() {} |
| |
| void GrCubicEffect::getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const { |
| GrGLCubicEffect::GenKey(*this, caps, b); |
| } |
| |
| GrGLSLPrimitiveProcessor* GrCubicEffect::createGLSLInstance(const GrShaderCaps&) const { |
| return new GrGLCubicEffect(*this); |
| } |
| |
| GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix, const SkMatrix& |
| devKLMMatrix, GrPrimitiveEdgeType edgeType) |
| : fColor(color) |
| , fViewMatrix(viewMatrix) |
| , fDevKLMMatrix(devKLMMatrix) |
| , fEdgeType(edgeType) { |
| this->initClassID<GrCubicEffect>(); |
| fInPosition = &this->addVertexAttrib("inPosition", kVec2f_GrVertexAttribType, |
| kHigh_GrSLPrecision); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect); |
| |
| #if GR_TEST_UTILS |
| sk_sp<GrGeometryProcessor> GrCubicEffect::TestCreate(GrProcessorTestData* d) { |
| sk_sp<GrGeometryProcessor> gp; |
| do { |
| GrPrimitiveEdgeType edgeType = |
| static_cast<GrPrimitiveEdgeType>( |
| d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt)); |
| gp = GrCubicEffect::Make(GrRandomColor(d->fRandom), GrTest::TestMatrix(d->fRandom), |
| GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool(), edgeType, |
| *d->caps()); |
| } while (nullptr == gp); |
| return gp; |
| } |
| #endif |
