blob: 861ff1bd3c70d4dea1ec28223446518a431f99a4 [file] [log] [blame]
jvanverth50530632015-04-27 10:36:27 -07001/*
2* Copyright 2013 Google Inc.
3*
4* Use of this source code is governed by a BSD-style license that can be
5* found in the LICENSE file.
6*/
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/GrPathProcessor.h"
Hal Canaryc640d0d2018-06-13 09:59:02 -04009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/private/SkTo.h"
11#include "src/gpu/GrShaderCaps.h"
12#include "src/gpu/gl/GrGLGpu.h"
13#include "src/gpu/gl/GrGLVaryingHandler.h"
14#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
15#include "src/gpu/glsl/GrGLSLPrimitiveProcessor.h"
16#include "src/gpu/glsl/GrGLSLUniformHandler.h"
17#include "src/gpu/glsl/GrGLSLVarying.h"
jvanverthcba99b82015-06-24 06:59:57 -070018
egdaniele659a582015-11-13 09:55:43 -080019class GrGLPathProcessor : public GrGLSLPrimitiveProcessor {
joshualitt102081a2015-09-11 11:52:17 -070020public:
Brian Osmancf860852018-10-31 14:04:39 -040021 GrGLPathProcessor() : fColor(SK_PMColor4fILLEGAL) {}
joshualitt102081a2015-09-11 11:52:17 -070022
23 static void GenKey(const GrPathProcessor& pathProc,
Brian Salomon94efbf52016-11-29 13:43:05 -050024 const GrShaderCaps&,
joshualitt102081a2015-09-11 11:52:17 -070025 GrProcessorKeyBuilder* b) {
Brian Salomonbfd51832017-01-04 13:22:08 -050026 b->add32(SkToInt(pathProc.viewMatrix().hasPerspective()));
joshualitt102081a2015-09-11 11:52:17 -070027 }
28
29 void emitCode(EmitArgs& args) override {
Chris Dalton60283612018-02-14 13:38:14 -070030 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
joshualitt102081a2015-09-11 11:52:17 -070031 const GrPathProcessor& pathProc = args.fGP.cast<GrPathProcessor>();
32
cdaltonc08f1962016-02-12 12:14:06 -080033 if (!pathProc.viewMatrix().hasPerspective()) {
34 args.fVaryingHandler->setNoPerspective();
35 }
36
joshualitt102081a2015-09-11 11:52:17 -070037 // emit transforms
bsalomona624bf32016-09-20 09:12:47 -070038 this->emitTransforms(args.fVaryingHandler, args.fFPCoordTransformHandler);
joshualitt102081a2015-09-11 11:52:17 -070039
40 // Setup uniform color
Brian Salomonbfd51832017-01-04 13:22:08 -050041 const char* stagedLocalVarName;
42 fColorUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
Ethan Nicholasf7b88202017-09-18 14:10:39 -040043 kHalf4_GrSLType,
Brian Salomonbfd51832017-01-04 13:22:08 -050044 "Color",
45 &stagedLocalVarName);
46 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, stagedLocalVarName);
joshualitt102081a2015-09-11 11:52:17 -070047
48 // setup constant solid coverage
Ethan Nicholasf7b88202017-09-18 14:10:39 -040049 fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
joshualitt102081a2015-09-11 11:52:17 -070050 }
51
Ethan Nicholasd4efe682019-08-29 16:10:13 -040052 SkString matrix_to_sksl(const SkMatrix& m) {
53 return SkStringPrintf("float3x3(%f, %f, %f, %f, %f, %f, %f, %f, %f)", m[0], m[1], m[2],
54 m[3], m[4], m[5], m[6], m[7], m[8]);
55 }
56
egdaniel0eafe792015-11-20 14:01:22 -080057 void emitTransforms(GrGLSLVaryingHandler* varyingHandler,
bsalomona624bf32016-09-20 09:12:47 -070058 FPCoordTransformHandler* transformHandler) {
59 int i = 0;
60 while (const GrCoordTransform* coordTransform = transformHandler->nextCoordTransform()) {
61 GrSLType varyingType =
Ethan Nicholasf7b88202017-09-18 14:10:39 -040062 coordTransform->getMatrix().hasPerspective() ? kHalf3_GrSLType
63 : kHalf2_GrSLType;
joshualitt102081a2015-09-11 11:52:17 -070064
bsalomona624bf32016-09-20 09:12:47 -070065 SkString strVaryingName;
66 strVaryingName.printf("TransformedCoord_%d", i);
Chris Dalton27372882017-12-08 13:34:21 -070067 GrGLSLVarying v(varyingType);
bsalomona624bf32016-09-20 09:12:47 -070068 GrGLVaryingHandler* glVaryingHandler = (GrGLVaryingHandler*) varyingHandler;
69 fInstalledTransforms.push_back().fHandle =
70 glVaryingHandler->addPathProcessingVarying(strVaryingName.c_str(),
71 &v).toIndex();
72 fInstalledTransforms.back().fType = varyingType;
joshualitt102081a2015-09-11 11:52:17 -070073
Ethan Nicholasd4efe682019-08-29 16:10:13 -040074 transformHandler->specifyCoordsForCurrCoordTransform(
75 matrix_to_sksl(coordTransform->getMatrix()),
76 UniformHandle(),
77 GrShaderVar(SkString(v.fsIn()),
78 varyingType));
bsalomona624bf32016-09-20 09:12:47 -070079 ++i;
joshualitt102081a2015-09-11 11:52:17 -070080 }
81 }
82
egdaniel018fb622015-10-28 07:26:40 -070083 void setData(const GrGLSLProgramDataManager& pd,
bsalomona624bf32016-09-20 09:12:47 -070084 const GrPrimitiveProcessor& primProc,
85 FPCoordTransformIter&& transformIter) override {
joshualitt102081a2015-09-11 11:52:17 -070086 const GrPathProcessor& pathProc = primProc.cast<GrPathProcessor>();
Brian Salomonbfd51832017-01-04 13:22:08 -050087 if (pathProc.color() != fColor) {
Brian Osmancf860852018-10-31 14:04:39 -040088 pd.set4fv(fColorUniform, 1, pathProc.color().vec());
joshualitt102081a2015-09-11 11:52:17 -070089 fColor = pathProc.color();
90 }
joshualitt102081a2015-09-11 11:52:17 -070091
bsalomona624bf32016-09-20 09:12:47 -070092 int t = 0;
93 while (const GrCoordTransform* coordTransform = transformIter.next()) {
94 SkASSERT(fInstalledTransforms[t].fHandle.isValid());
95 const SkMatrix& m = GetTransformMatrix(pathProc.localMatrix(), *coordTransform);
96 if (fInstalledTransforms[t].fCurrentValue.cheapEqualTo(m)) {
joshualitt102081a2015-09-11 11:52:17 -070097 continue;
98 }
bsalomona624bf32016-09-20 09:12:47 -070099 fInstalledTransforms[t].fCurrentValue = m;
joshualitt102081a2015-09-11 11:52:17 -0700100
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400101 SkASSERT(fInstalledTransforms[t].fType == kHalf2_GrSLType ||
102 fInstalledTransforms[t].fType == kHalf3_GrSLType);
103 unsigned components = fInstalledTransforms[t].fType == kHalf2_GrSLType ? 2 : 3;
bsalomona624bf32016-09-20 09:12:47 -0700104 pd.setPathFragmentInputTransform(fInstalledTransforms[t].fHandle, components, m);
105 ++t;
joshualitt102081a2015-09-11 11:52:17 -0700106 }
107 }
108
109private:
egdanielfe8a8392016-05-09 10:22:19 -0700110 typedef GrGLSLProgramDataManager::VaryingHandle VaryingHandle;
bsalomon790c90b2016-09-12 12:56:58 -0700111 struct TransformVarying {
egdanielfe8a8392016-05-09 10:22:19 -0700112 VaryingHandle fHandle;
bsalomon790c90b2016-09-12 12:56:58 -0700113 SkMatrix fCurrentValue = SkMatrix::InvalidMatrix();
114 GrSLType fType = kVoid_GrSLType;
egdanielfe8a8392016-05-09 10:22:19 -0700115 };
116
bsalomona624bf32016-09-20 09:12:47 -0700117 SkTArray<TransformVarying, true> fInstalledTransforms;
egdanielfe8a8392016-05-09 10:22:19 -0700118
joshualitt102081a2015-09-11 11:52:17 -0700119 UniformHandle fColorUniform;
Brian Osmancf860852018-10-31 14:04:39 -0400120 SkPMColor4f fColor;
joshualitt102081a2015-09-11 11:52:17 -0700121
egdaniele659a582015-11-13 09:55:43 -0800122 typedef GrGLSLPrimitiveProcessor INHERITED;
joshualitt102081a2015-09-11 11:52:17 -0700123};
124
Brian Osmancf860852018-10-31 14:04:39 -0400125GrPathProcessor::GrPathProcessor(const SkPMColor4f& color,
joshualitt8072caa2015-02-12 14:20:52 -0800126 const SkMatrix& viewMatrix,
127 const SkMatrix& localMatrix)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400128 : INHERITED(kGrPathProcessor_ClassID)
129 , fColor(color)
Brian Salomon92aee3d2016-12-21 09:20:25 -0500130 , fViewMatrix(viewMatrix)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400131 , fLocalMatrix(localMatrix) {}
joshualitt8072caa2015-02-12 14:20:52 -0800132
Brian Salomon94efbf52016-11-29 13:43:05 -0500133void GrPathProcessor::getGLSLProcessorKey(const GrShaderCaps& caps,
egdaniel57d3b032015-11-13 11:57:27 -0800134 GrProcessorKeyBuilder* b) const {
joshualitt465283c2015-09-11 08:19:35 -0700135 GrGLPathProcessor::GenKey(*this, caps, b);
joshualitt8072caa2015-02-12 14:20:52 -0800136}
137
Brian Salomon94efbf52016-11-29 13:43:05 -0500138GrGLSLPrimitiveProcessor* GrPathProcessor::createGLSLInstance(const GrShaderCaps& caps) const {
jvanverth50530632015-04-27 10:36:27 -0700139 SkASSERT(caps.pathRenderingSupport());
joshualitt465283c2015-09-11 08:19:35 -0700140 return new GrGLPathProcessor();
joshualitt8072caa2015-02-12 14:20:52 -0800141}