Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018 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 Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "src/gpu/effects/GrSkSLFP.h" |
Robert Phillips | 1efecea | 2019-02-15 16:58:40 -0500 | [diff] [blame] | 9 | |
Brian Osman | ee426f2 | 2020-01-02 11:55:24 -0500 | [diff] [blame] | 10 | #include "include/effects/SkRuntimeEffect.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/gpu/GrTexture.h" |
| 12 | #include "include/private/GrContext_Base.h" |
| 13 | #include "src/gpu/GrBaseContextPriv.h" |
| 14 | #include "src/sksl/SkSLUtil.h" |
Robert Phillips | 1efecea | 2019-02-15 16:58:40 -0500 | [diff] [blame] | 15 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 16 | #include "src/gpu/glsl/GrGLSLFragmentProcessor.h" |
| 17 | #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h" |
| 18 | #include "src/gpu/glsl/GrGLSLProgramBuilder.h" |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 19 | |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 20 | class GrGLSLSkSLFP : public GrGLSLFragmentProcessor { |
| 21 | public: |
Brian Osman | 300fe1d | 2020-01-23 15:42:43 -0500 | [diff] [blame] | 22 | GrGLSLSkSLFP(SkSL::PipelineStageArgs&& args) : fArgs(std::move(args)) {} |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 23 | |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 24 | SkSL::String expandFormatArgs(const SkSL::String& raw, |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 25 | EmitArgs& args, |
| 26 | std::vector<SkSL::Compiler::FormatArg>::const_iterator& fmtArg, |
| 27 | const char* coordsName) { |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 28 | SkSL::String result; |
| 29 | int substringStartIndex = 0; |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 30 | for (size_t i = 0; i < raw.length(); ++i) { |
| 31 | char c = raw[i]; |
| 32 | if (c == '%') { |
| 33 | result += SkSL::StringFragment(raw.c_str() + substringStartIndex, |
| 34 | i - substringStartIndex); |
| 35 | ++i; |
| 36 | c = raw[i]; |
| 37 | switch (c) { |
| 38 | case 's': { |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 39 | const SkSL::Compiler::FormatArg& arg = *fmtArg++; |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 40 | switch (arg.fKind) { |
| 41 | case SkSL::Compiler::FormatArg::Kind::kInput: |
| 42 | result += args.fInputColor; |
| 43 | break; |
| 44 | case SkSL::Compiler::FormatArg::Kind::kOutput: |
| 45 | result += args.fOutputColor; |
| 46 | break; |
| 47 | case SkSL::Compiler::FormatArg::Kind::kCoordX: |
| 48 | result += coordsName; |
| 49 | result += ".x"; |
| 50 | break; |
| 51 | case SkSL::Compiler::FormatArg::Kind::kCoordY: |
| 52 | result += coordsName; |
| 53 | result += ".y"; |
| 54 | break; |
| 55 | case SkSL::Compiler::FormatArg::Kind::kUniform: |
| 56 | result += args.fUniformHandler->getUniformCStr( |
| 57 | fUniformHandles[arg.fIndex]); |
| 58 | break; |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 59 | case SkSL::Compiler::FormatArg::Kind::kChildProcessor: { |
| 60 | SkSL::String coords = this->expandFormatArgs(arg.fCoords, args, |
| 61 | fmtArg, coordsName); |
| 62 | result += this->invokeChild(arg.fIndex, args, coords).c_str(); |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 63 | break; |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 64 | } |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 65 | case SkSL::Compiler::FormatArg::Kind::kFunctionName: |
| 66 | SkASSERT((int) fFunctionNames.size() > arg.fIndex); |
| 67 | result += fFunctionNames[arg.fIndex].c_str(); |
| 68 | break; |
| 69 | } |
| 70 | break; |
| 71 | } |
| 72 | default: |
| 73 | result += c; |
| 74 | } |
| 75 | substringStartIndex = i + 1; |
| 76 | } |
| 77 | } |
| 78 | result += SkSL::StringFragment(raw.c_str() + substringStartIndex, |
| 79 | raw.length() - substringStartIndex); |
| 80 | return result; |
| 81 | } |
| 82 | |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 83 | void emitCode(EmitArgs& args) override { |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 84 | const GrSkSLFP& fp = args.fFp.cast<GrSkSLFP>(); |
Brian Osman | f72dedd | 2020-01-08 13:19:58 -0500 | [diff] [blame] | 85 | for (const auto& v : fp.fEffect->inputs()) { |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 86 | if (v.fQualifier == SkRuntimeEffect::Variable::Qualifier::kUniform) { |
| 87 | auto handle = args.fUniformHandler->addUniformArray(kFragment_GrShaderFlag, |
| 88 | v.fGPUType, |
| 89 | v.fName.c_str(), |
| 90 | v.isArray() ? v.fCount : 0); |
| 91 | fUniformHandles.push_back(handle); |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 92 | } |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 93 | } |
Brian Osman | 2e29ab5 | 2019-09-20 12:19:11 -0400 | [diff] [blame] | 94 | GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; |
Brian Osman | ab2f7c5 | 2020-02-06 13:31:15 -0500 | [diff] [blame] | 95 | SkASSERT(args.fTransformedCoords.count() == 1); |
| 96 | SkString coords = fragBuilder->ensureCoords2D(args.fTransformedCoords[0].fVaryingPoint); |
Brian Salomon | d4bf54e | 2020-01-27 17:50:36 +0000 | [diff] [blame] | 97 | std::vector<SkString> childNames; |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 98 | // We need to ensure that we call invokeChild on each child FP at least once. |
| 99 | // Any child FP that isn't sampled won't trigger a call otherwise, leading to asserts later. |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 100 | for (int i = 0; i < this->numChildProcessors(); ++i) { |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 101 | (void)this->invokeChild(i, args, SkSL::String("_coords")); |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 102 | } |
Brian Osman | 300fe1d | 2020-01-23 15:42:43 -0500 | [diff] [blame] | 103 | for (const auto& f : fArgs.fFunctions) { |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 104 | fFunctionNames.emplace_back(); |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 105 | auto fmtArgIter = f.fFormatArgs.cbegin(); |
| 106 | SkSL::String body = |
| 107 | this->expandFormatArgs(f.fBody.c_str(), args, fmtArgIter, coords.c_str()); |
| 108 | SkASSERT(fmtArgIter == f.fFormatArgs.cend()); |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 109 | fragBuilder->emitFunction(f.fReturnType, |
| 110 | f.fName.c_str(), |
| 111 | f.fParameters.size(), |
| 112 | f.fParameters.data(), |
| 113 | body.c_str(), |
| 114 | &fFunctionNames.back()); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 115 | } |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 116 | auto fmtArgIter = fArgs.fFormatArgs.cbegin(); |
| 117 | fragBuilder->codeAppend(this->expandFormatArgs(fArgs.fCode.c_str(), args, fmtArgIter, |
| 118 | coords.c_str()).c_str()); |
| 119 | SkASSERT(fmtArgIter == fArgs.fFormatArgs.cend()); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 120 | } |
| 121 | |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 122 | void onSetData(const GrGLSLProgramDataManager& pdman, |
| 123 | const GrFragmentProcessor& _proc) override { |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 124 | size_t uniIndex = 0; |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 125 | const GrSkSLFP& outer = _proc.cast<GrSkSLFP>(); |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 126 | const uint8_t* inputs = outer.fInputs->bytes(); |
Brian Osman | f72dedd | 2020-01-08 13:19:58 -0500 | [diff] [blame] | 127 | for (const auto& v : outer.fEffect->inputs()) { |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 128 | if (v.fQualifier != SkRuntimeEffect::Variable::Qualifier::kUniform) { |
| 129 | continue; |
| 130 | } |
| 131 | |
| 132 | const float* data = reinterpret_cast<const float*>(inputs + v.fOffset); |
| 133 | switch (v.fType) { |
| 134 | case SkRuntimeEffect::Variable::Type::kFloat: |
| 135 | pdman.set1fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | c1c686b | 2019-04-02 17:30:23 -0400 | [diff] [blame] | 136 | break; |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 137 | case SkRuntimeEffect::Variable::Type::kFloat2: |
| 138 | pdman.set2fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 139 | break; |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 140 | case SkRuntimeEffect::Variable::Type::kFloat3: |
| 141 | pdman.set3fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | fc671ad | 2019-11-21 11:14:11 -0500 | [diff] [blame] | 142 | break; |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 143 | case SkRuntimeEffect::Variable::Type::kFloat4: |
| 144 | pdman.set4fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | c1c686b | 2019-04-02 17:30:23 -0400 | [diff] [blame] | 145 | break; |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 146 | case SkRuntimeEffect::Variable::Type::kFloat2x2: |
| 147 | pdman.setMatrix2fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | c1c686b | 2019-04-02 17:30:23 -0400 | [diff] [blame] | 148 | break; |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 149 | case SkRuntimeEffect::Variable::Type::kFloat3x3: |
| 150 | pdman.setMatrix3fv(fUniformHandles[uniIndex++], v.fCount, data); |
| 151 | break; |
| 152 | case SkRuntimeEffect::Variable::Type::kFloat4x4: |
| 153 | pdman.setMatrix4fv(fUniformHandles[uniIndex++], v.fCount, data); |
Ethan Nicholas | c1c686b | 2019-04-02 17:30:23 -0400 | [diff] [blame] | 154 | break; |
| 155 | default: |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 156 | SkDEBUGFAIL("Unsupported uniform type"); |
| 157 | break; |
Ethan Nicholas | 222e275 | 2018-10-11 11:21:34 -0400 | [diff] [blame] | 158 | } |
Ethan Nicholas | 222e275 | 2018-10-11 11:21:34 -0400 | [diff] [blame] | 159 | } |
| 160 | } |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 161 | |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 162 | // nearly-finished GLSL; still contains printf-style "%s" format tokens |
Brian Osman | 300fe1d | 2020-01-23 15:42:43 -0500 | [diff] [blame] | 163 | SkSL::PipelineStageArgs fArgs; |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 164 | std::vector<UniformHandle> fUniformHandles; |
Brian Osman | 2e29ab5 | 2019-09-20 12:19:11 -0400 | [diff] [blame] | 165 | std::vector<SkString> fFunctionNames; |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 166 | }; |
| 167 | |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 168 | std::unique_ptr<GrSkSLFP> GrSkSLFP::Make(GrContext_Base* context, sk_sp<SkRuntimeEffect> effect, |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 169 | const char* name, sk_sp<SkData> inputs, |
Brian Osman | 3b1e4c2 | 2019-08-12 15:12:14 -0400 | [diff] [blame] | 170 | const SkMatrix* matrix) { |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 171 | if (inputs->size() != effect->inputSize()) { |
| 172 | return nullptr; |
| 173 | } |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 174 | return std::unique_ptr<GrSkSLFP>(new GrSkSLFP(context->priv().caps()->refShaderCaps(), |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 175 | std::move(effect), name, std::move(inputs), |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 176 | matrix)); |
Ethan Nicholas | a70693b | 2019-03-04 13:07:36 -0500 | [diff] [blame] | 177 | } |
| 178 | |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 179 | GrSkSLFP::GrSkSLFP(sk_sp<const GrShaderCaps> shaderCaps, sk_sp<SkRuntimeEffect> effect, |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 180 | const char* name, sk_sp<SkData> inputs, const SkMatrix* matrix) |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 181 | : INHERITED(kGrSkSLFP_ClassID, kNone_OptimizationFlags) |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 182 | , fShaderCaps(std::move(shaderCaps)) |
| 183 | , fEffect(std::move(effect)) |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 184 | , fName(name) |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 185 | , fInputs(std::move(inputs)) { |
Brian Osman | 3b1e4c2 | 2019-08-12 15:12:14 -0400 | [diff] [blame] | 186 | if (matrix) { |
| 187 | fCoordTransform = GrCoordTransform(*matrix); |
Brian Osman | 3b1e4c2 | 2019-08-12 15:12:14 -0400 | [diff] [blame] | 188 | } |
Brian Osman | ab2f7c5 | 2020-02-06 13:31:15 -0500 | [diff] [blame] | 189 | this->addCoordTransform(&fCoordTransform); |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 190 | } |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 191 | |
| 192 | GrSkSLFP::GrSkSLFP(const GrSkSLFP& other) |
| 193 | : INHERITED(kGrSkSLFP_ClassID, kNone_OptimizationFlags) |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 194 | , fShaderCaps(other.fShaderCaps) |
| 195 | , fEffect(other.fEffect) |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 196 | , fName(other.fName) |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 197 | , fInputs(other.fInputs) { |
Brian Osman | ab2f7c5 | 2020-02-06 13:31:15 -0500 | [diff] [blame] | 198 | SkASSERT(other.numCoordTransforms() == 1); |
| 199 | fCoordTransform = other.fCoordTransform; |
| 200 | this->addCoordTransform(&fCoordTransform); |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 201 | } |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 202 | |
| 203 | const char* GrSkSLFP::name() const { |
| 204 | return fName; |
| 205 | } |
| 206 | |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 207 | void GrSkSLFP::addChild(std::unique_ptr<GrFragmentProcessor> child) { |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 208 | child->setSampledWithExplicitCoords(true); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 209 | this->registerChildProcessor(std::move(child)); |
| 210 | } |
| 211 | |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 212 | GrGLSLFragmentProcessor* GrSkSLFP::onCreateGLSLInstance() const { |
Brian Osman | 7b1678a | 2019-12-16 09:17:25 -0500 | [diff] [blame] | 213 | // Note: This is actually SkSL (again) but with inline format specifiers. |
Brian Osman | 107c666 | 2019-12-30 15:02:30 -0500 | [diff] [blame] | 214 | SkSL::PipelineStageArgs args; |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 215 | SkAssertResult(fEffect->toPipelineStage(fInputs->data(), fShaderCaps.get(), &args)); |
Brian Osman | 300fe1d | 2020-01-23 15:42:43 -0500 | [diff] [blame] | 216 | return new GrGLSLSkSLFP(std::move(args)); |
Greg Daniel | f410794 | 2019-12-12 01:02:48 +0000 | [diff] [blame] | 217 | } |
| 218 | |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 219 | void GrSkSLFP::onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const { |
Brian Osman | 3225306 | 2020-02-05 11:37:08 -0500 | [diff] [blame] | 220 | // In the unlikely event of a hash collision, we also include the input size in the key. |
| 221 | // That ensures that we will (at worst) use the wrong program, but one that expects the same |
| 222 | // amount of input data. |
| 223 | b->add32(fEffect->hash()); |
| 224 | b->add32(SkToU32(fInputs->size())); |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 225 | const uint8_t* inputs = fInputs->bytes(); |
Brian Osman | f72dedd | 2020-01-08 13:19:58 -0500 | [diff] [blame] | 226 | for (const auto& v : fEffect->inputs()) { |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 227 | if (v.fQualifier != SkRuntimeEffect::Variable::Qualifier::kIn) { |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 228 | continue; |
Ethan Nicholas | c1c686b | 2019-04-02 17:30:23 -0400 | [diff] [blame] | 229 | } |
Brian Osman | d927bd2 | 2019-12-18 11:23:12 -0500 | [diff] [blame] | 230 | // 'in' arrays are not supported |
| 231 | SkASSERT(!v.isArray()); |
| 232 | switch (v.fType) { |
| 233 | case SkRuntimeEffect::Variable::Type::kBool: |
| 234 | b->add32(inputs[v.fOffset]); |
| 235 | break; |
| 236 | case SkRuntimeEffect::Variable::Type::kInt: |
| 237 | case SkRuntimeEffect::Variable::Type::kFloat: |
| 238 | b->add32(*(int32_t*)(inputs + v.fOffset)); |
| 239 | break; |
| 240 | default: |
| 241 | SkDEBUGFAIL("Unsupported input variable type"); |
| 242 | break; |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 243 | } |
| 244 | } |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | bool GrSkSLFP::onIsEqual(const GrFragmentProcessor& other) const { |
| 248 | const GrSkSLFP& sk = other.cast<GrSkSLFP>(); |
Brian Osman | 3225306 | 2020-02-05 11:37:08 -0500 | [diff] [blame] | 249 | return fEffect->hash() == sk.fEffect->hash() && fInputs->equals(sk.fInputs.get()); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | std::unique_ptr<GrFragmentProcessor> GrSkSLFP::clone() const { |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 253 | std::unique_ptr<GrSkSLFP> result(new GrSkSLFP(*this)); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 254 | for (int i = 0; i < this->numChildProcessors(); ++i) { |
Brian Osman | 87e3bef | 2020-01-27 16:21:34 -0500 | [diff] [blame^] | 255 | result->addChild(this->childProcessor(i).clone()); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 256 | } |
| 257 | return std::unique_ptr<GrFragmentProcessor>(result.release()); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 258 | } |
| 259 | |
Robert Phillips | 7f11fb5 | 2019-12-03 13:35:19 -0500 | [diff] [blame] | 260 | /**************************************************************************************************/ |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 261 | |
| 262 | GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSkSLFP); |
| 263 | |
| 264 | #if GR_TEST_UTILS |
| 265 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 266 | #include "include/effects/SkArithmeticImageFilter.h" |
| 267 | #include "include/gpu/GrContext.h" |
| 268 | #include "src/gpu/effects/generated/GrConstColorProcessor.h" |
Ethan Nicholas | 78aceb2 | 2018-08-31 16:13:58 -0400 | [diff] [blame] | 269 | |
| 270 | extern const char* SKSL_ARITHMETIC_SRC; |
| 271 | extern const char* SKSL_DITHER_SRC; |
| 272 | extern const char* SKSL_OVERDRAW_SRC; |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 273 | |
| 274 | using Value = SkSL::Program::Settings::Value; |
| 275 | |
| 276 | std::unique_ptr<GrFragmentProcessor> GrSkSLFP::TestCreate(GrProcessorTestData* d) { |
Ethan Nicholas | eace935 | 2018-10-15 20:09:54 +0000 | [diff] [blame] | 277 | int type = d->fRandom->nextULessThan(3); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 278 | switch (type) { |
| 279 | case 0: { |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 280 | static auto effect = std::get<0>(SkRuntimeEffect::Make(SkString(SKSL_DITHER_SRC))); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 281 | int rangeType = d->fRandom->nextULessThan(3); |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 282 | auto result = GrSkSLFP::Make(d->context(), effect, "Dither", |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 283 | SkData::MakeWithCopy(&rangeType, sizeof(rangeType))); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 284 | return std::unique_ptr<GrFragmentProcessor>(result.release()); |
| 285 | } |
| 286 | case 1: { |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 287 | static auto effect = std::get<0>(SkRuntimeEffect::Make(SkString(SKSL_ARITHMETIC_SRC))); |
Brian Osman | 0a3c57f | 2020-02-05 13:13:32 -0500 | [diff] [blame] | 288 | ArithmeticFPInputs inputs{d->fRandom->nextF(), d->fRandom->nextF(), d->fRandom->nextF(), |
| 289 | d->fRandom->nextF(), d->fRandom->nextBool()}; |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 290 | auto result = GrSkSLFP::Make(d->context(), effect, "Arithmetic", |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 291 | SkData::MakeWithCopy(&inputs, sizeof(inputs))); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 292 | result->addChild(GrConstColorProcessor::Make( |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 293 | SK_PMColor4fWHITE, GrConstColorProcessor::InputMode::kIgnore)); |
Ethan Nicholas | ce00811 | 2018-08-30 09:19:50 -0400 | [diff] [blame] | 294 | return std::unique_ptr<GrFragmentProcessor>(result.release()); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 295 | } |
Ethan Nicholas | 78aceb2 | 2018-08-31 16:13:58 -0400 | [diff] [blame] | 296 | case 2: { |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 297 | static auto effect = std::get<0>(SkRuntimeEffect::Make(SkString(SKSL_OVERDRAW_SRC))); |
Brian Osman | 9d10abe | 2019-12-13 16:31:40 -0500 | [diff] [blame] | 298 | SkColor4f inputs[6]; |
Ethan Nicholas | 78aceb2 | 2018-08-31 16:13:58 -0400 | [diff] [blame] | 299 | for (int i = 0; i < 6; ++i) { |
Brian Osman | 9d10abe | 2019-12-13 16:31:40 -0500 | [diff] [blame] | 300 | inputs[i] = SkColor4f::FromBytes_RGBA(d->fRandom->nextU()); |
Ethan Nicholas | 78aceb2 | 2018-08-31 16:13:58 -0400 | [diff] [blame] | 301 | } |
Brian Osman | 088913a | 2019-12-19 15:44:56 -0500 | [diff] [blame] | 302 | auto result = GrSkSLFP::Make(d->context(), effect, "Overdraw", |
Brian Osman | 9bfd595 | 2020-02-05 10:51:44 -0500 | [diff] [blame] | 303 | SkData::MakeWithCopy(&inputs, sizeof(inputs))); |
Ethan Nicholas | 78aceb2 | 2018-08-31 16:13:58 -0400 | [diff] [blame] | 304 | return std::unique_ptr<GrFragmentProcessor>(result.release()); |
| 305 | } |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 306 | } |
| 307 | SK_ABORT("unreachable"); |
Ethan Nicholas | 0054311 | 2018-07-31 09:44:36 -0400 | [diff] [blame] | 308 | } |
| 309 | |
| 310 | #endif |