egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
| 8 | #include "glsl/GrGLSLProgramBuilder.h" |
| 9 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 10 | #include "GrCaps.h" |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 11 | #include "GrPipeline.h" |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 12 | #include "GrRenderTarget.h" |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 13 | #include "GrShaderCaps.h" |
Brian Salomon | 739c5bf | 2016-11-07 09:53:44 -0500 | [diff] [blame] | 14 | #include "GrTexturePriv.h" |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 15 | #include "glsl/GrGLSLFragmentProcessor.h" |
| 16 | #include "glsl/GrGLSLGeometryProcessor.h" |
egdaniel | 9f1d415 | 2016-02-10 09:50:38 -0800 | [diff] [blame] | 17 | #include "glsl/GrGLSLVarying.h" |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 18 | #include "glsl/GrGLSLXferProcessor.h" |
Robert Phillips | fe8da17 | 2018-01-24 14:52:02 +0000 | [diff] [blame] | 19 | #include "SkSLCompiler.h" |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 20 | |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 21 | const int GrGLSLProgramBuilder::kVarsPerBlock = 8; |
| 22 | |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 23 | GrGLSLProgramBuilder::GrGLSLProgramBuilder(GrRenderTarget* renderTarget, GrSurfaceOrigin origin, |
| 24 | const GrPrimitiveProcessor& primProc, |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 25 | const GrTextureProxy* const primProcProxies[], |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 26 | const GrPipeline& pipeline, |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 27 | GrProgramDesc* desc) |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 28 | : fVS(this) |
| 29 | , fGS(this) |
| 30 | , fFS(this) |
| 31 | , fStageIndex(-1) |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 32 | , fRenderTarget(renderTarget) |
Robert Phillips | d0fe875 | 2019-01-31 14:13:59 -0500 | [diff] [blame] | 33 | , fOrigin(origin) |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 34 | , fPipeline(pipeline) |
| 35 | , fPrimProc(primProc) |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 36 | , fPrimProcProxies(primProcProxies) |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 37 | , fDesc(desc) |
| 38 | , fGeometryProcessor(nullptr) |
| 39 | , fXferProcessor(nullptr) |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 40 | , fNumFragmentSamplers(0) {} |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 41 | |
| 42 | void GrGLSLProgramBuilder::addFeature(GrShaderFlags shaders, |
| 43 | uint32_t featureBit, |
| 44 | const char* extensionName) { |
| 45 | if (shaders & kVertex_GrShaderFlag) { |
| 46 | fVS.addFeature(featureBit, extensionName); |
| 47 | } |
| 48 | if (shaders & kGeometry_GrShaderFlag) { |
csmartdalton | 276cc41 | 2016-11-21 11:55:00 -0700 | [diff] [blame] | 49 | SkASSERT(this->primitiveProcessor().willUseGeoShader()); |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 50 | fGS.addFeature(featureBit, extensionName); |
| 51 | } |
| 52 | if (shaders & kFragment_GrShaderFlag) { |
| 53 | fFS.addFeature(featureBit, extensionName); |
| 54 | } |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 55 | } |
| 56 | |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 57 | bool GrGLSLProgramBuilder::emitAndInstallProcs() { |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 58 | // First we loop over all of the installed processors and collect coord transforms. These will |
| 59 | // be sent to the GrGLSLPrimitiveProcessor in its emitCode function |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 60 | SkString inputColor; |
| 61 | SkString inputCoverage; |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 62 | this->emitAndInstallPrimProc(&inputColor, &inputCoverage); |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 63 | this->emitAndInstallFragProcs(&inputColor, &inputCoverage); |
| 64 | this->emitAndInstallXferProc(inputColor, inputCoverage); |
Brian Salomon | 42c456f | 2017-03-06 11:29:48 -0500 | [diff] [blame] | 65 | this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput()); |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 66 | |
Brian Salomon | 559f556 | 2017-11-15 14:28:33 -0500 | [diff] [blame] | 67 | return this->checkSamplerCounts(); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 68 | } |
| 69 | |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 70 | void GrGLSLProgramBuilder::emitAndInstallPrimProc(SkString* outputColor, |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 71 | SkString* outputCoverage) { |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 72 | const GrPrimitiveProcessor& proc = this->primitiveProcessor(); |
| 73 | const GrTextureProxy* const* primProcProxies = this->primProcProxies(); |
| 74 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 75 | // Program builders have a bit of state we need to clear with each effect |
| 76 | AutoStageAdvance adv(this); |
| 77 | this->nameExpression(outputColor, "outputColor"); |
| 78 | this->nameExpression(outputCoverage, "outputCoverage"); |
| 79 | |
csmartdalton | 936f81b | 2017-02-13 15:45:35 -0700 | [diff] [blame] | 80 | SkASSERT(!fUniformHandles.fRTAdjustmentUni.isValid()); |
Robert Phillips | fe8da17 | 2018-01-24 14:52:02 +0000 | [diff] [blame] | 81 | GrShaderFlags rtAdjustVisibility; |
csmartdalton | 936f81b | 2017-02-13 15:45:35 -0700 | [diff] [blame] | 82 | if (proc.willUseGeoShader()) { |
Robert Phillips | fe8da17 | 2018-01-24 14:52:02 +0000 | [diff] [blame] | 83 | rtAdjustVisibility = kGeometry_GrShaderFlag; |
| 84 | } else { |
| 85 | rtAdjustVisibility = kVertex_GrShaderFlag; |
csmartdalton | 936f81b | 2017-02-13 15:45:35 -0700 | [diff] [blame] | 86 | } |
Robert Phillips | fe8da17 | 2018-01-24 14:52:02 +0000 | [diff] [blame] | 87 | fUniformHandles.fRTAdjustmentUni = this->uniformHandler()->addUniform( |
| 88 | rtAdjustVisibility, |
| 89 | kFloat4_GrSLType, |
| 90 | SkSL::Compiler::RTADJUST_NAME); |
csmartdalton | 936f81b | 2017-02-13 15:45:35 -0700 | [diff] [blame] | 91 | const char* rtAdjustName = |
| 92 | this->uniformHandler()->getUniformCStr(fUniformHandles.fRTAdjustmentUni); |
| 93 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 94 | // Enclose custom code in a block to avoid namespace conflicts |
| 95 | SkString openBrace; |
| 96 | openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name()); |
| 97 | fFS.codeAppend(openBrace.c_str()); |
| 98 | fVS.codeAppendf("// Primitive Processor %s\n", proc.name()); |
| 99 | |
| 100 | SkASSERT(!fGeometryProcessor); |
Robert Phillips | 369e8b7 | 2017-08-01 16:13:04 -0400 | [diff] [blame] | 101 | fGeometryProcessor.reset(proc.createGLSLInstance(*this->shaderCaps())); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 102 | |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 103 | SkAutoSTMalloc<4, SamplerHandle> texSamplers(proc.numTextureSamplers()); |
| 104 | for (int i = 0; i < proc.numTextureSamplers(); ++i) { |
| 105 | SkString name; |
| 106 | name.printf("TextureSampler_%d", i); |
| 107 | const auto& sampler = proc.textureSampler(i); |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 108 | const GrTexture* texture = primProcProxies[i]->peekTexture(); |
| 109 | SkASSERT(sampler.textureType() == texture->texturePriv().textureType()); |
| 110 | SkASSERT(sampler.config() == texture->config()); |
| 111 | texSamplers[i] = this->emitSampler(texture, |
| 112 | sampler.samplerState(), |
| 113 | name.c_str()); |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 114 | } |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 115 | |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 116 | GrGLSLPrimitiveProcessor::FPCoordTransformHandler transformHandler(fPipeline, |
| 117 | &fTransformedCoordVars); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 118 | GrGLSLGeometryProcessor::EmitArgs args(&fVS, |
csmartdalton | 276cc41 | 2016-11-21 11:55:00 -0700 | [diff] [blame] | 119 | proc.willUseGeoShader() ? &fGS : nullptr, |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 120 | &fFS, |
| 121 | this->varyingHandler(), |
| 122 | this->uniformHandler(), |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 123 | this->shaderCaps(), |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 124 | proc, |
| 125 | outputColor->c_str(), |
| 126 | outputCoverage->c_str(), |
csmartdalton | 936f81b | 2017-02-13 15:45:35 -0700 | [diff] [blame] | 127 | rtAdjustName, |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 128 | texSamplers.get(), |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 129 | &transformHandler); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 130 | fGeometryProcessor->emitCode(args); |
| 131 | |
| 132 | // We have to check that effects and the code they emit are consistent, ie if an effect |
| 133 | // asks for dst color, then the emit code needs to follow suit |
cdalton | 8733210 | 2016-02-26 12:22:02 -0800 | [diff] [blame] | 134 | SkDEBUGCODE(verify(proc);) |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 135 | |
| 136 | fFS.codeAppend("}"); |
| 137 | } |
| 138 | |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 139 | void GrGLSLProgramBuilder::emitAndInstallFragProcs(SkString* color, SkString* coverage) { |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 140 | int transformedCoordVarsIdx = 0; |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 141 | SkString** inOut = &color; |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 142 | SkSTArray<8, std::unique_ptr<GrGLSLFragmentProcessor>> glslFragmentProcessors; |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 143 | for (int i = 0; i < this->pipeline().numFragmentProcessors(); ++i) { |
| 144 | if (i == this->pipeline().numColorFragmentProcessors()) { |
| 145 | inOut = &coverage; |
| 146 | } |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 147 | SkString output; |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 148 | const GrFragmentProcessor& fp = this->pipeline().getFragmentProcessor(i); |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 149 | output = this->emitAndInstallFragProc(fp, i, transformedCoordVarsIdx, **inOut, output, |
| 150 | &glslFragmentProcessors); |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 151 | GrFragmentProcessor::Iter iter(&fp); |
| 152 | while (const GrFragmentProcessor* fp = iter.next()) { |
| 153 | transformedCoordVarsIdx += fp->numCoordTransforms(); |
| 154 | } |
| 155 | **inOut = output; |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 156 | } |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 157 | fFragmentProcessorCnt = glslFragmentProcessors.count(); |
| 158 | fFragmentProcessors.reset(new std::unique_ptr<GrGLSLFragmentProcessor>[fFragmentProcessorCnt]); |
| 159 | for (int i = 0; i < fFragmentProcessorCnt; ++i) { |
| 160 | fFragmentProcessors[i] = std::move(glslFragmentProcessors[i]); |
| 161 | } |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | // TODO Processors cannot output zeros because an empty string is all 1s |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 165 | // the fix is to allow effects to take the SkString directly |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 166 | SkString GrGLSLProgramBuilder::emitAndInstallFragProc( |
| 167 | const GrFragmentProcessor& fp, |
| 168 | int index, |
| 169 | int transformedCoordVarsIdx, |
| 170 | const SkString& input, |
| 171 | SkString output, |
| 172 | SkTArray<std::unique_ptr<GrGLSLFragmentProcessor>>* glslFragmentProcessors) { |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 173 | SkASSERT(input.size()); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 174 | // Program builders have a bit of state we need to clear with each effect |
| 175 | AutoStageAdvance adv(this); |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 176 | this->nameExpression(&output, "output"); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 177 | |
| 178 | // Enclose custom code in a block to avoid namespace conflicts |
| 179 | SkString openBrace; |
| 180 | openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name()); |
| 181 | fFS.codeAppend(openBrace.c_str()); |
| 182 | |
| 183 | GrGLSLFragmentProcessor* fragProc = fp.createGLSLInstance(); |
| 184 | |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 185 | SkSTArray<4, SamplerHandle> texSamplers; |
| 186 | GrFragmentProcessor::Iter fpIter(&fp); |
| 187 | int samplerIdx = 0; |
| 188 | while (const auto* subFP = fpIter.next()) { |
| 189 | for (int i = 0; i < subFP->numTextureSamplers(); ++i) { |
| 190 | SkString name; |
| 191 | name.printf("TextureSampler_%d", samplerIdx++); |
| 192 | const auto& sampler = subFP->textureSampler(i); |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 193 | texSamplers.emplace_back(this->emitSampler(sampler.peekTexture(), |
| 194 | sampler.samplerState(), |
Greg Daniel | 0f70be8 | 2018-10-08 17:35:08 +0000 | [diff] [blame] | 195 | name.c_str())); |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 196 | } |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 197 | } |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 198 | |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 199 | const GrShaderVar* coordVars = fTransformedCoordVars.begin() + transformedCoordVarsIdx; |
| 200 | GrGLSLFragmentProcessor::TransformedCoordVars coords(&fp, coordVars); |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 201 | GrGLSLFragmentProcessor::TextureSamplers textureSamplers(&fp, texSamplers.begin()); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 202 | GrGLSLFragmentProcessor::EmitArgs args(&fFS, |
| 203 | this->uniformHandler(), |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 204 | this->shaderCaps(), |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 205 | fp, |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 206 | output.c_str(), |
| 207 | input.c_str(), |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 208 | coords, |
Brian Salomon | 662ea4b | 2018-07-12 14:53:49 -0400 | [diff] [blame] | 209 | textureSamplers); |
dvonbeck | 9b03e7b | 2016-08-01 11:01:56 -0700 | [diff] [blame] | 210 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 211 | fragProc->emitCode(args); |
| 212 | |
| 213 | // We have to check that effects and the code they emit are consistent, ie if an effect |
| 214 | // asks for dst color, then the emit code needs to follow suit |
cdalton | 8733210 | 2016-02-26 12:22:02 -0800 | [diff] [blame] | 215 | SkDEBUGCODE(verify(fp);) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 216 | glslFragmentProcessors->emplace_back(fragProc); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 217 | |
| 218 | fFS.codeAppend("}"); |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 219 | return output; |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 220 | } |
| 221 | |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 222 | void GrGLSLProgramBuilder::emitAndInstallXferProc(const SkString& colorIn, |
| 223 | const SkString& coverageIn) { |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 224 | // Program builders have a bit of state we need to clear with each effect |
| 225 | AutoStageAdvance adv(this); |
| 226 | |
| 227 | SkASSERT(!fXferProcessor); |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 228 | const GrXferProcessor& xp = fPipeline.getXferProcessor(); |
Robert Phillips | 369e8b7 | 2017-08-01 16:13:04 -0400 | [diff] [blame] | 229 | fXferProcessor.reset(xp.createGLSLInstance()); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 230 | |
| 231 | // Enable dual source secondary output if we have one |
| 232 | if (xp.hasSecondaryOutput()) { |
| 233 | fFS.enableSecondaryOutput(); |
| 234 | } |
| 235 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 236 | if (this->shaderCaps()->mustDeclareFragmentShaderOutput()) { |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 237 | fFS.enableCustomOutput(); |
| 238 | } |
| 239 | |
| 240 | SkString openBrace; |
| 241 | openBrace.printf("{ // Xfer Processor: %s\n", xp.name()); |
| 242 | fFS.codeAppend(openBrace.c_str()); |
| 243 | |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 244 | SamplerHandle dstTextureSamplerHandle; |
| 245 | GrSurfaceOrigin dstTextureOrigin = kTopLeft_GrSurfaceOrigin; |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 246 | |
| 247 | if (GrTexture* dstTexture = fPipeline.peekDstTexture()) { |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 248 | // GrProcessor::TextureSampler sampler(dstTexture); |
| 249 | SkString name("DstTextureSampler"); |
| 250 | dstTextureSamplerHandle = |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 251 | this->emitSampler(dstTexture, GrSamplerState(), "DstTextureSampler"); |
Robert Phillips | 16d8ec6 | 2017-07-27 16:16:25 -0400 | [diff] [blame] | 252 | dstTextureOrigin = fPipeline.dstTextureProxy()->origin(); |
Brian Salomon | 60dd8c7 | 2018-07-30 10:24:13 -0400 | [diff] [blame] | 253 | SkASSERT(dstTexture->texturePriv().textureType() != GrTextureType::kExternal); |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 254 | } |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 255 | |
Brian Osman | 65cdd61 | 2019-03-14 17:01:57 -0400 | [diff] [blame] | 256 | SkString finalInColor; |
| 257 | if (colorIn.size()) { |
| 258 | if (this->desc()->header().fClampBlendInput) { |
| 259 | finalInColor.printf("saturate(%s)", colorIn.c_str()); |
| 260 | } else { |
| 261 | finalInColor = colorIn; |
| 262 | } |
| 263 | } else { |
| 264 | finalInColor = "float4(1)"; |
| 265 | } |
| 266 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 267 | GrGLSLXferProcessor::EmitArgs args(&fFS, |
| 268 | this->uniformHandler(), |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 269 | this->shaderCaps(), |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 270 | xp, |
Brian Osman | 65cdd61 | 2019-03-14 17:01:57 -0400 | [diff] [blame] | 271 | finalInColor.c_str(), |
Ethan Nicholas | 5af9ea3 | 2017-07-28 15:19:46 -0400 | [diff] [blame] | 272 | coverageIn.size() ? coverageIn.c_str() : "float4(1)", |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 273 | fFS.getPrimaryColorOutputName(), |
| 274 | fFS.getSecondaryColorOutputName(), |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 275 | dstTextureSamplerHandle, |
| 276 | dstTextureOrigin); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 277 | fXferProcessor->emitCode(args); |
| 278 | |
| 279 | // We have to check that effects and the code they emit are consistent, ie if an effect |
| 280 | // asks for dst color, then the emit code needs to follow suit |
cdalton | 8733210 | 2016-02-26 12:22:02 -0800 | [diff] [blame] | 281 | SkDEBUGCODE(verify(xp);) |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 282 | fFS.codeAppend("}"); |
| 283 | } |
| 284 | |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 285 | GrGLSLProgramBuilder::SamplerHandle GrGLSLProgramBuilder::emitSampler(const GrTexture* texture, |
| 286 | const GrSamplerState& state, |
Greg Daniel | 0f70be8 | 2018-10-08 17:35:08 +0000 | [diff] [blame] | 287 | const char* name) { |
| 288 | ++fNumFragmentSamplers; |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 289 | return this->uniformHandler()->addSampler(texture, state, name, this->shaderCaps()); |
Brian Salomon | f9f4512 | 2016-11-29 11:59:17 -0500 | [diff] [blame] | 290 | } |
| 291 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 292 | void GrGLSLProgramBuilder::emitFSOutputSwizzle(bool hasSecondaryOutput) { |
| 293 | // Swizzle the fragment shader outputs if necessary. |
| 294 | GrSwizzle swizzle; |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 295 | swizzle.setFromKey(this->desc()->header().fOutputSwizzle); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 296 | if (swizzle != GrSwizzle::RGBA()) { |
| 297 | fFS.codeAppendf("%s = %s.%s;", fFS.getPrimaryColorOutputName(), |
| 298 | fFS.getPrimaryColorOutputName(), |
| 299 | swizzle.c_str()); |
| 300 | if (hasSecondaryOutput) { |
| 301 | fFS.codeAppendf("%s = %s.%s;", fFS.getSecondaryColorOutputName(), |
| 302 | fFS.getSecondaryColorOutputName(), |
| 303 | swizzle.c_str()); |
| 304 | } |
| 305 | } |
| 306 | } |
| 307 | |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 308 | bool GrGLSLProgramBuilder::checkSamplerCounts() { |
Brian Salomon | 1edc5b9 | 2016-11-29 13:43:46 -0500 | [diff] [blame] | 309 | const GrShaderCaps& shaderCaps = *this->shaderCaps(); |
Brian Salomon | 1edc5b9 | 2016-11-29 13:43:46 -0500 | [diff] [blame] | 310 | if (fNumFragmentSamplers > shaderCaps.maxFragmentSamplers()) { |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 311 | GrCapsDebugf(this->caps(), "Program would use too many fragment samplers\n"); |
| 312 | return false; |
| 313 | } |
cdalton | 9c3f143 | 2016-03-11 10:07:37 -0800 | [diff] [blame] | 314 | return true; |
| 315 | } |
| 316 | |
cdalton | 8733210 | 2016-02-26 12:22:02 -0800 | [diff] [blame] | 317 | #ifdef SK_DEBUG |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 318 | void GrGLSLProgramBuilder::verify(const GrPrimitiveProcessor& gp) { |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 319 | SkASSERT(!fFS.fHasReadDstColorThisStage_DebugOnly); |
| 320 | SkASSERT(fFS.fUsedProcessorFeaturesThisStage_DebugOnly == gp.requestedFeatures()); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | void GrGLSLProgramBuilder::verify(const GrFragmentProcessor& fp) { |
Chris Dalton | d7291ba | 2019-03-07 14:17:03 -0700 | [diff] [blame] | 324 | SkASSERT(!fFS.fHasReadDstColorThisStage_DebugOnly); |
| 325 | SkASSERT(fFS.fUsedProcessorFeaturesThisStage_DebugOnly == fp.requestedFeatures()); |
| 326 | } |
| 327 | |
| 328 | void GrGLSLProgramBuilder::verify(const GrXferProcessor& xp) { |
| 329 | SkASSERT(xp.willReadDstColor() == fFS.fHasReadDstColorThisStage_DebugOnly); |
| 330 | SkASSERT(fFS.fUsedProcessorFeaturesThisStage_DebugOnly == xp.requestedFeatures()); |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 331 | } |
cdalton | 8733210 | 2016-02-26 12:22:02 -0800 | [diff] [blame] | 332 | #endif |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 333 | |
| 334 | void GrGLSLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) { |
| 335 | if ('\0' == prefix) { |
| 336 | *out = name; |
| 337 | } else { |
| 338 | out->printf("%c%s", prefix, name); |
| 339 | } |
| 340 | if (mangle) { |
| 341 | if (out->endsWith('_')) { |
| 342 | // Names containing "__" are reserved. |
| 343 | out->append("x"); |
| 344 | } |
| 345 | out->appendf("_Stage%d%s", fStageIndex, fFS.getMangleString().c_str()); |
| 346 | } |
| 347 | } |
| 348 | |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 349 | void GrGLSLProgramBuilder::nameExpression(SkString* output, const char* baseName) { |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 350 | // create var to hold stage result. If we already have a valid output name, just use that |
| 351 | // otherwise create a new mangled one. This name is only valid if we are reordering stages |
| 352 | // and have to tell stage exactly where to put its output. |
| 353 | SkString outName; |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 354 | if (output->size()) { |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 355 | outName = output->c_str(); |
| 356 | } else { |
| 357 | this->nameVariable(&outName, '\0', baseName); |
| 358 | } |
Ethan Nicholas | f7b8820 | 2017-09-18 14:10:39 -0400 | [diff] [blame] | 359 | fFS.codeAppendf("half4 %s;", outName.c_str()); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 360 | *output = outName; |
| 361 | } |
| 362 | |
cdalton | 5e58cee | 2016-02-11 12:49:47 -0800 | [diff] [blame] | 363 | void GrGLSLProgramBuilder::appendUniformDecls(GrShaderFlags visibility, SkString* out) const { |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 364 | this->uniformHandler()->appendUniformDecls(visibility, out); |
| 365 | } |
| 366 | |
Ethan Nicholas | cd700e9 | 2018-08-24 16:43:57 -0400 | [diff] [blame] | 367 | void GrGLSLProgramBuilder::addRTWidthUniform(const char* name) { |
| 368 | SkASSERT(!fUniformHandles.fRTWidthUni.isValid()); |
| 369 | GrGLSLUniformHandler* uniformHandler = this->uniformHandler(); |
| 370 | fUniformHandles.fRTWidthUni = |
Ethan Nicholas | 858fecc | 2019-03-07 13:19:18 -0500 | [diff] [blame] | 371 | uniformHandler->internalAddUniformArray(kFragment_GrShaderFlag, kHalf_GrSLType, name, |
| 372 | false, 0, nullptr); |
Ethan Nicholas | cd700e9 | 2018-08-24 16:43:57 -0400 | [diff] [blame] | 373 | } |
| 374 | |
Greg Daniel | e6ab998 | 2018-08-22 13:56:32 +0000 | [diff] [blame] | 375 | void GrGLSLProgramBuilder::addRTHeightUniform(const char* name) { |
| 376 | SkASSERT(!fUniformHandles.fRTHeightUni.isValid()); |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 377 | GrGLSLUniformHandler* uniformHandler = this->uniformHandler(); |
Greg Daniel | e6ab998 | 2018-08-22 13:56:32 +0000 | [diff] [blame] | 378 | fUniformHandles.fRTHeightUni = |
Ethan Nicholas | 858fecc | 2019-03-07 13:19:18 -0500 | [diff] [blame] | 379 | uniformHandler->internalAddUniformArray(kFragment_GrShaderFlag, kHalf_GrSLType, name, |
| 380 | false, 0, nullptr); |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 381 | } |
| 382 | |
egdaniel | 9f1d415 | 2016-02-10 09:50:38 -0800 | [diff] [blame] | 383 | void GrGLSLProgramBuilder::finalizeShaders() { |
| 384 | this->varyingHandler()->finalize(); |
cdalton | 5e58cee | 2016-02-11 12:49:47 -0800 | [diff] [blame] | 385 | fVS.finalize(kVertex_GrShaderFlag); |
csmartdalton | 276cc41 | 2016-11-21 11:55:00 -0700 | [diff] [blame] | 386 | if (this->primitiveProcessor().willUseGeoShader()) { |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 387 | SkASSERT(this->shaderCaps()->geometryShaderSupport()); |
csmartdalton | 276cc41 | 2016-11-21 11:55:00 -0700 | [diff] [blame] | 388 | fGS.finalize(kGeometry_GrShaderFlag); |
| 389 | } |
cdalton | 5e58cee | 2016-02-11 12:49:47 -0800 | [diff] [blame] | 390 | fFS.finalize(kFragment_GrShaderFlag); |
egdaniel | 9f1d415 | 2016-02-10 09:50:38 -0800 | [diff] [blame] | 391 | } |