joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 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 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 8 | #include "GrGLProgramBuilder.h" |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 9 | |
bsalomon | 6f7f201 | 2015-03-16 14:00:52 -0700 | [diff] [blame] | 10 | #include "GrAutoLocaleSetter.h" |
Robert Phillips | 9bee2e5 | 2017-05-29 12:37:20 -0400 | [diff] [blame] | 11 | #include "GrContext.h" |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 12 | #include "GrContextPriv.h" |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 13 | #include "GrCoordTransform.h" |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 14 | #include "GrGLProgramBuilder.h" |
egdaniel | 5d8f69f | 2016-09-07 07:24:12 -0700 | [diff] [blame] | 15 | #include "GrProgramDesc.h" |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 16 | #include "GrShaderCaps.h" |
bsalomon | 7f9b2e4 | 2016-01-12 13:29:26 -0800 | [diff] [blame] | 17 | #include "GrSwizzle.h" |
Hal Canary | 95e3c05 | 2017-01-11 12:44:43 -0500 | [diff] [blame] | 18 | #include "SkAutoMalloc.h" |
Derek Sollenberger | 488f0d6 | 2017-03-03 15:48:33 -0500 | [diff] [blame] | 19 | #include "SkATrace.h" |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 20 | #include "SkTraceEvent.h" |
joshualitt | e7afc2d | 2015-09-11 10:44:13 -0700 | [diff] [blame] | 21 | #include "gl/GrGLGpu.h" |
joshualitt | e7afc2d | 2015-09-11 10:44:13 -0700 | [diff] [blame] | 22 | #include "gl/GrGLProgram.h" |
egdaniel | 574a4c1 | 2015-11-02 06:22:44 -0800 | [diff] [blame] | 23 | #include "gl/builders/GrGLShaderStringBuilder.h" |
egdaniel | 64c4728 | 2015-11-13 06:54:19 -0800 | [diff] [blame] | 24 | #include "glsl/GrGLSLFragmentProcessor.h" |
egdaniel | e659a58 | 2015-11-13 09:55:43 -0800 | [diff] [blame] | 25 | #include "glsl/GrGLSLGeometryProcessor.h" |
egdaniel | 018fb62 | 2015-10-28 07:26:40 -0700 | [diff] [blame] | 26 | #include "glsl/GrGLSLProgramDataManager.h" |
egdaniel | fa4cc8b | 2015-11-13 08:34:52 -0800 | [diff] [blame] | 27 | #include "glsl/GrGLSLXferProcessor.h" |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 28 | |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 29 | #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X) |
| 30 | #define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X) |
| 31 | |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 32 | GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrPrimitiveProcessor& primProc, |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 33 | const GrTextureProxy* const primProcProxies[], |
Brian Salomon | ff168d9 | 2018-06-23 15:17:27 -0400 | [diff] [blame] | 34 | const GrPipeline& pipeline, |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 35 | GrProgramDesc* desc, |
egdaniel | 0e1853c | 2016-03-17 11:35:45 -0700 | [diff] [blame] | 36 | GrGLGpu* gpu) { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 37 | SkASSERT(!pipeline.isBad()); |
Robert Phillips | a91e0b7 | 2017-05-01 13:12:20 -0400 | [diff] [blame] | 38 | |
Derek Sollenberger | 488f0d6 | 2017-03-03 15:48:33 -0500 | [diff] [blame] | 39 | ATRACE_ANDROID_FRAMEWORK("Shader Compile"); |
bsalomon | 3318ee7 | 2015-03-16 11:56:29 -0700 | [diff] [blame] | 40 | GrAutoLocaleSetter als("C"); |
| 41 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 42 | // create a builder. This will be handed off to effects so they can use it to add |
| 43 | // uniforms, varyings, textures, etc |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 44 | GrGLProgramBuilder builder(gpu, pipeline, primProc, primProcProxies, desc); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 45 | |
Robert Phillips | 0c4b7b1 | 2018-03-06 08:20:37 -0500 | [diff] [blame] | 46 | auto persistentCache = gpu->getContext()->contextPriv().getPersistentCache(); |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 47 | if (persistentCache && gpu->glCaps().programBinarySupport()) { |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 48 | sk_sp<SkData> key = SkData::MakeWithoutCopy(desc->asKey(), desc->keyLength()); |
Robert Phillips | 0c4b7b1 | 2018-03-06 08:20:37 -0500 | [diff] [blame] | 49 | builder.fCached = persistentCache->load(*key); |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 50 | // the eventual end goal is to completely skip emitAndInstallProcs on a cache hit, but it's |
| 51 | // doing necessary setup in addition to generating the SkSL code. Currently we are only able |
| 52 | // to skip the SkSL->GLSL step on a cache hit. |
| 53 | } |
Ethan Nicholas | 2983f40 | 2017-05-08 09:36:08 -0400 | [diff] [blame] | 54 | if (!builder.emitAndInstallProcs()) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 55 | return nullptr; |
joshualitt | 6c89110 | 2015-05-13 08:51:49 -0700 | [diff] [blame] | 56 | } |
egdaniel | c1e7101 | 2016-01-20 07:53:51 -0800 | [diff] [blame] | 57 | return builder.finalize(); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 58 | } |
| 59 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 60 | ///////////////////////////////////////////////////////////////////////////// |
| 61 | |
egdaniel | 0e1853c | 2016-03-17 11:35:45 -0700 | [diff] [blame] | 62 | GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, |
| 63 | const GrPipeline& pipeline, |
| 64 | const GrPrimitiveProcessor& primProc, |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 65 | const GrTextureProxy* const primProcProxies[], |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 66 | GrProgramDesc* desc) |
Greg Daniel | 9a51a86 | 2018-11-30 10:18:14 -0500 | [diff] [blame] | 67 | : INHERITED(primProc, primProcProxies, pipeline, desc) |
Brian Salomon | 802cb31 | 2018-06-08 18:05:20 -0400 | [diff] [blame] | 68 | , fGpu(gpu) |
| 69 | , fVaryingHandler(this) |
| 70 | , fUniformHandler(this) |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 71 | , fVertexAttributeCnt(0) |
| 72 | , fInstanceAttributeCnt(0) |
Brian Salomon | 802cb31 | 2018-06-08 18:05:20 -0400 | [diff] [blame] | 73 | , fVertexStride(0) |
| 74 | , fInstanceStride(0) {} |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 75 | |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 76 | const GrCaps* GrGLProgramBuilder::caps() const { |
| 77 | return fGpu->caps(); |
| 78 | } |
| 79 | |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 80 | bool GrGLProgramBuilder::compileAndAttachShaders(const char* glsl, |
| 81 | int length, |
egdaniel | 574a4c1 | 2015-11-02 06:22:44 -0800 | [diff] [blame] | 82 | GrGLuint programId, |
| 83 | GrGLenum type, |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 84 | SkTDArray<GrGLuint>* shaderIds, |
| 85 | const SkSL::Program::Settings& settings, |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 86 | const SkSL::Program::Inputs& inputs) { |
egdaniel | 574a4c1 | 2015-11-02 06:22:44 -0800 | [diff] [blame] | 87 | GrGLGpu* gpu = this->gpu(); |
| 88 | GrGLuint shaderId = GrGLCompileAndAttachShader(gpu->glContext(), |
| 89 | programId, |
| 90 | type, |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 91 | glsl, |
| 92 | length, |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 93 | gpu->stats(), |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 94 | settings); |
egdaniel | 574a4c1 | 2015-11-02 06:22:44 -0800 | [diff] [blame] | 95 | if (!shaderId) { |
| 96 | return false; |
| 97 | } |
| 98 | |
| 99 | *shaderIds->append() = shaderId; |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 100 | if (inputs.fFlipY) { |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 101 | GrProgramDesc* d = this->desc(); |
Robert Phillips | 7f86192 | 2018-01-30 13:13:42 +0000 | [diff] [blame] | 102 | d->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin( |
| 103 | this->pipeline().proxy()->origin())); |
Ethan Nicholas | 3865711 | 2017-02-09 17:01:22 -0500 | [diff] [blame] | 104 | d->finalize(); |
| 105 | } |
egdaniel | 574a4c1 | 2015-11-02 06:22:44 -0800 | [diff] [blame] | 106 | |
| 107 | return true; |
| 108 | } |
| 109 | |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 110 | bool GrGLProgramBuilder::compileAndAttachShaders(GrGLSLShaderBuilder& shader, |
| 111 | GrGLuint programId, |
| 112 | GrGLenum type, |
| 113 | SkTDArray<GrGLuint>* shaderIds, |
| 114 | const SkSL::Program::Settings& settings, |
| 115 | SkSL::Program::Inputs* outInputs) { |
| 116 | SkSL::String glsl; |
| 117 | std::unique_ptr<SkSL::Program> program = GrSkSLtoGLSL(gpu()->glContext(), type, |
| 118 | shader.fCompilerStrings.begin(), |
| 119 | shader.fCompilerStringLengths.begin(), |
| 120 | shader.fCompilerStrings.count(), |
| 121 | settings, |
| 122 | &glsl); |
| 123 | *outInputs = program->fInputs; |
| 124 | return this->compileAndAttachShaders(glsl.c_str(), |
| 125 | glsl.size(), |
| 126 | programId, |
| 127 | type, |
| 128 | shaderIds, |
| 129 | settings, |
| 130 | *outInputs); |
| 131 | } |
| 132 | |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 133 | void GrGLProgramBuilder::computeCountsAndStrides(GrGLuint programID, |
| 134 | const GrPrimitiveProcessor& primProc, |
| 135 | bool bindAttribLocations) { |
| 136 | fVertexAttributeCnt = primProc.numVertexAttributes(); |
| 137 | fInstanceAttributeCnt = primProc.numInstanceAttributes(); |
| 138 | fAttributes.reset( |
| 139 | new GrGLProgram::Attribute[fVertexAttributeCnt + fInstanceAttributeCnt]); |
| 140 | auto addAttr = [&](int i, const auto& a, size_t* stride) { |
Brian Osman | 4a3f5c8 | 2018-09-18 16:16:38 -0400 | [diff] [blame] | 141 | fAttributes[i].fCPUType = a.cpuType(); |
| 142 | fAttributes[i].fGPUType = a.gpuType(); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 143 | fAttributes[i].fOffset = *stride; |
| 144 | *stride += a.sizeAlign4(); |
| 145 | fAttributes[i].fLocation = i; |
| 146 | if (bindAttribLocations) { |
| 147 | GL_CALL(BindAttribLocation(programID, i, a.name())); |
| 148 | } |
| 149 | }; |
| 150 | fVertexStride = 0; |
| 151 | int i = 0; |
Brian Osman | f04fb3c | 2018-11-12 15:34:00 -0500 | [diff] [blame] | 152 | for (const auto& attr : primProc.vertexAttributes()) { |
| 153 | addAttr(i++, attr, &fVertexStride); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 154 | } |
Brian Osman | f04fb3c | 2018-11-12 15:34:00 -0500 | [diff] [blame] | 155 | SkASSERT(fVertexStride == primProc.vertexStride()); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 156 | fInstanceStride = 0; |
Brian Osman | f04fb3c | 2018-11-12 15:34:00 -0500 | [diff] [blame] | 157 | for (const auto& attr : primProc.instanceAttributes()) { |
| 158 | addAttr(i++, attr, &fInstanceStride); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 159 | } |
Brian Osman | f04fb3c | 2018-11-12 15:34:00 -0500 | [diff] [blame] | 160 | SkASSERT(fInstanceStride == primProc.instanceStride()); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 161 | } |
| 162 | |
Ethan Nicholas | cd700e9 | 2018-08-24 16:43:57 -0400 | [diff] [blame] | 163 | void GrGLProgramBuilder::addInputVars(const SkSL::Program::Inputs& inputs) { |
| 164 | if (inputs.fRTWidth) { |
| 165 | this->addRTWidthUniform(SKSL_RTWIDTH_NAME); |
| 166 | } |
| 167 | if (inputs.fRTHeight) { |
| 168 | this->addRTHeightUniform(SKSL_RTHEIGHT_NAME); |
| 169 | } |
| 170 | } |
| 171 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 172 | GrGLProgram* GrGLProgramBuilder::finalize() { |
Brian Osman | 39c08ac | 2017-07-26 09:36:09 -0400 | [diff] [blame] | 173 | TRACE_EVENT0("skia", TRACE_FUNC); |
Ryan Macnak | 38a10ad | 2017-07-10 10:36:34 -0700 | [diff] [blame] | 174 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 175 | // verify we can get a program id |
| 176 | GrGLuint programID; |
| 177 | GL_CALL_RET(programID, CreateProgram()); |
| 178 | if (0 == programID) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 179 | return nullptr; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 180 | } |
| 181 | |
Ethan Nicholas | 06d55fb | 2017-11-08 09:48:50 -0500 | [diff] [blame] | 182 | if (this->gpu()->glCaps().programBinarySupport() && |
Robert Phillips | 0c4b7b1 | 2018-03-06 08:20:37 -0500 | [diff] [blame] | 183 | this->gpu()->getContext()->contextPriv().getPersistentCache()) { |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 184 | GL_CALL(ProgramParameteri(programID, GR_GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GR_GL_TRUE)); |
| 185 | } |
| 186 | |
egdaniel | 9f1d415 | 2016-02-10 09:50:38 -0800 | [diff] [blame] | 187 | this->finalizeShaders(); |
| 188 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 189 | // compile shaders and bind attributes / uniforms |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 190 | const GrPrimitiveProcessor& primProc = this->primitiveProcessor(); |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 191 | SkSL::Program::Settings settings; |
| 192 | settings.fCaps = this->gpu()->glCaps().shaderCaps(); |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 193 | settings.fFlipY = this->pipeline().proxy()->origin() != kTopLeft_GrSurfaceOrigin; |
Brian Osman | 8a83ca4 | 2018-02-12 14:32:17 -0500 | [diff] [blame] | 194 | settings.fSharpenTextures = this->gpu()->getContext()->contextPriv().sharpenMipmappedTextures(); |
Brian Salomon | dc09213 | 2018-04-04 10:14:16 -0400 | [diff] [blame] | 195 | settings.fFragColorIsInOut = this->fragColorIsInOut(); |
| 196 | |
Ethan Nicholas | 941e7e2 | 2016-12-12 15:33:30 -0500 | [diff] [blame] | 197 | SkSL::Program::Inputs inputs; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 198 | SkTDArray<GrGLuint> shadersToDelete; |
Ethan Nicholas | 5a0338c | 2019-01-02 11:48:56 -0500 | [diff] [blame^] | 199 | // Calling GetProgramiv is expensive in Chromium. Assume success in release builds. |
| 200 | bool checkLinked = kChromium_GrGLDriver != fGpu->ctxInfo().driver(); |
| 201 | #ifdef SK_DEBUG |
| 202 | checkLinked = true; |
| 203 | #endif |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 204 | bool cached = fGpu->glCaps().programBinarySupport() && nullptr != fCached.get(); |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 205 | if (cached) { |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 206 | this->bindProgramResourceLocations(programID); |
| 207 | // cache hit, just hand the binary to GL |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 208 | const uint8_t* bytes = fCached->bytes(); |
| 209 | size_t offset = 0; |
| 210 | memcpy(&inputs, bytes + offset, sizeof(inputs)); |
| 211 | offset += sizeof(inputs); |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 212 | int binaryFormat; |
| 213 | memcpy(&binaryFormat, bytes + offset, sizeof(binaryFormat)); |
| 214 | offset += sizeof(binaryFormat); |
| 215 | GrGLClearErr(this->gpu()->glInterface()); |
| 216 | GR_GL_CALL_NOERRCHECK(this->gpu()->glInterface(), |
| 217 | ProgramBinary(programID, binaryFormat, (void*) (bytes + offset), |
| 218 | fCached->size() - offset)); |
| 219 | if (GR_GL_GET_ERROR(this->gpu()->glInterface()) == GR_GL_NO_ERROR) { |
Ethan Nicholas | 5a0338c | 2019-01-02 11:48:56 -0500 | [diff] [blame^] | 220 | if (checkLinked) { |
| 221 | cached = this->checkLinkStatus(programID); |
| 222 | } |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 223 | if (cached) { |
| 224 | this->addInputVars(inputs); |
| 225 | this->computeCountsAndStrides(programID, primProc, false); |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 226 | } |
Ethan Nicholas | 98ad5b7 | 2018-03-13 09:53:02 -0400 | [diff] [blame] | 227 | } else { |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 228 | cached = false; |
Ethan Nicholas | 98ad5b7 | 2018-03-13 09:53:02 -0400 | [diff] [blame] | 229 | } |
| 230 | } |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 231 | if (!cached) { |
| 232 | // cache miss, compile shaders |
| 233 | if (fFS.fForceHighPrecision) { |
| 234 | settings.fForceHighPrecision = true; |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 235 | } |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 236 | SkSL::String glsl; |
| 237 | std::unique_ptr<SkSL::Program> fs = GrSkSLtoGLSL(gpu()->glContext(), |
| 238 | GR_GL_FRAGMENT_SHADER, |
| 239 | fFS.fCompilerStrings.begin(), |
| 240 | fFS.fCompilerStringLengths.begin(), |
| 241 | fFS.fCompilerStrings.count(), |
| 242 | settings, |
| 243 | &glsl); |
| 244 | if (!fs) { |
| 245 | this->cleanupProgram(programID, shadersToDelete); |
| 246 | return nullptr; |
| 247 | } |
| 248 | inputs = fs->fInputs; |
Ethan Nicholas | cd700e9 | 2018-08-24 16:43:57 -0400 | [diff] [blame] | 249 | this->addInputVars(inputs); |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 250 | if (!this->compileAndAttachShaders(glsl.c_str(), glsl.size(), programID, |
| 251 | GR_GL_FRAGMENT_SHADER, &shadersToDelete, settings, |
| 252 | inputs)) { |
| 253 | this->cleanupProgram(programID, shadersToDelete); |
| 254 | return nullptr; |
| 255 | } |
| 256 | |
| 257 | std::unique_ptr<SkSL::Program> vs = GrSkSLtoGLSL(gpu()->glContext(), |
| 258 | GR_GL_VERTEX_SHADER, |
| 259 | fVS.fCompilerStrings.begin(), |
| 260 | fVS.fCompilerStringLengths.begin(), |
| 261 | fVS.fCompilerStrings.count(), |
| 262 | settings, |
| 263 | &glsl); |
Brian Salomon | 7c93472 | 2018-06-01 14:42:53 -0400 | [diff] [blame] | 264 | if (!vs || !this->compileAndAttachShaders(glsl.c_str(), glsl.size(), programID, |
| 265 | GR_GL_VERTEX_SHADER, &shadersToDelete, settings, |
| 266 | inputs)) { |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 267 | this->cleanupProgram(programID, shadersToDelete); |
| 268 | return nullptr; |
| 269 | } |
| 270 | |
| 271 | // NVPR actually requires a vertex shader to compile |
| 272 | bool useNvpr = primProc.isPathRendering(); |
| 273 | if (!useNvpr) { |
Ethan Nicholas | ad77dce | 2018-07-11 13:59:03 -0400 | [diff] [blame] | 274 | this->computeCountsAndStrides(programID, primProc, true); |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | if (primProc.willUseGeoShader()) { |
| 278 | std::unique_ptr<SkSL::Program> gs; |
| 279 | gs = GrSkSLtoGLSL(gpu()->glContext(), |
| 280 | GR_GL_GEOMETRY_SHADER, |
| 281 | fGS.fCompilerStrings.begin(), |
| 282 | fGS.fCompilerStringLengths.begin(), |
| 283 | fGS.fCompilerStrings.count(), |
| 284 | settings, |
| 285 | &glsl); |
Brian Salomon | 7c93472 | 2018-06-01 14:42:53 -0400 | [diff] [blame] | 286 | if (!gs || !this->compileAndAttachShaders(glsl.c_str(), glsl.size(), programID, |
| 287 | GR_GL_GEOMETRY_SHADER, &shadersToDelete, |
| 288 | settings, inputs)) { |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 289 | this->cleanupProgram(programID, shadersToDelete); |
| 290 | return nullptr; |
| 291 | } |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 292 | } |
| 293 | this->bindProgramResourceLocations(programID); |
| 294 | |
| 295 | GL_CALL(LinkProgram(programID)); |
Ethan Nicholas | 5a0338c | 2019-01-02 11:48:56 -0500 | [diff] [blame^] | 296 | if (checkLinked) { |
| 297 | if (!this->checkLinkStatus(programID)) { |
| 298 | GL_CALL(DeleteProgram(programID)); |
| 299 | SkDebugf("VS:\n"); |
| 300 | GrGLPrintShader(fGpu->glContext(), |
| 301 | GR_GL_VERTEX_SHADER, |
| 302 | fVS.fCompilerStrings.begin(), |
| 303 | fVS.fCompilerStringLengths.begin(), |
| 304 | fVS.fCompilerStrings.count(), |
| 305 | settings); |
| 306 | if (primProc.willUseGeoShader()) { |
| 307 | SkDebugf("\nGS:\n"); |
| 308 | GrGLPrintShader(fGpu->glContext(), |
| 309 | GR_GL_GEOMETRY_SHADER, |
| 310 | fGS.fCompilerStrings.begin(), |
| 311 | fGS.fCompilerStringLengths.begin(), |
| 312 | fGS.fCompilerStrings.count(), settings); |
| 313 | } |
| 314 | SkDebugf("\nFS:\n"); |
| 315 | GrGLPrintShader(fGpu->glContext(), |
| 316 | GR_GL_FRAGMENT_SHADER, |
| 317 | fFS.fCompilerStrings.begin(), |
| 318 | fFS.fCompilerStringLengths.begin(), |
| 319 | fFS.fCompilerStrings.count(), |
| 320 | settings); |
| 321 | return nullptr; |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 322 | } |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 323 | } |
joshualitt | fe1233c | 2014-10-07 12:16:35 -0700 | [diff] [blame] | 324 | } |
kkinnunen | 7aedda5 | 2015-06-29 23:01:28 -0700 | [diff] [blame] | 325 | this->resolveProgramResourceLocations(programID); |
joshualitt | db0d3ca | 2014-10-07 12:42:26 -0700 | [diff] [blame] | 326 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 327 | this->cleanupShaders(shadersToDelete); |
Ethan Nicholas | 255f73a | 2018-12-12 20:54:32 +0000 | [diff] [blame] | 328 | if (!cached && this->gpu()->getContext()->contextPriv().getPersistentCache() && |
| 329 | fGpu->glCaps().programBinarySupport()) { |
| 330 | GrGLsizei length = 0; |
| 331 | GL_CALL(GetProgramiv(programID, GL_PROGRAM_BINARY_LENGTH, &length)); |
| 332 | if (length > 0) { |
| 333 | // store shader in cache |
| 334 | sk_sp<SkData> key = SkData::MakeWithoutCopy(desc()->asKey(), desc()->keyLength()); |
| 335 | GrGLenum binaryFormat; |
| 336 | std::unique_ptr<char[]> binary(new char[length]); |
| 337 | GL_CALL(GetProgramBinary(programID, length, &length, &binaryFormat, binary.get())); |
| 338 | size_t dataLength = sizeof(inputs) + sizeof(binaryFormat) + length; |
| 339 | std::unique_ptr<uint8_t[]> data(new uint8_t[dataLength]); |
| 340 | size_t offset = 0; |
| 341 | memcpy(data.get() + offset, &inputs, sizeof(inputs)); |
| 342 | offset += sizeof(inputs); |
| 343 | memcpy(data.get() + offset, &binaryFormat, sizeof(binaryFormat)); |
| 344 | offset += sizeof(binaryFormat); |
| 345 | memcpy(data.get() + offset, binary.get(), length); |
| 346 | this->gpu()->getContext()->contextPriv().getPersistentCache()->store( |
| 347 | *key, *SkData::MakeWithoutCopy(data.get(), dataLength)); |
| 348 | } |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 349 | } |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 350 | return this->createProgram(programID); |
| 351 | } |
| 352 | |
kkinnunen | 7aedda5 | 2015-06-29 23:01:28 -0700 | [diff] [blame] | 353 | void GrGLProgramBuilder::bindProgramResourceLocations(GrGLuint programID) { |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 354 | fUniformHandler.bindUniformLocations(programID, fGpu->glCaps()); |
kkinnunen | 7aedda5 | 2015-06-29 23:01:28 -0700 | [diff] [blame] | 355 | |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 356 | const GrGLCaps& caps = this->gpu()->glCaps(); |
| 357 | if (fFS.hasCustomColorOutput() && caps.bindFragDataLocationSupport()) { |
| 358 | GL_CALL(BindFragDataLocation(programID, 0, |
egdaniel | 2d721d3 | 2015-11-11 13:06:05 -0800 | [diff] [blame] | 359 | GrGLSLFragmentShaderBuilder::DeclaredColorOutputName())); |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 360 | } |
Brian Salomon | 1edc5b9 | 2016-11-29 13:43:46 -0500 | [diff] [blame] | 361 | if (fFS.hasSecondaryOutput() && caps.shaderCaps()->mustDeclareFragmentShaderOutput()) { |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 362 | GL_CALL(BindFragDataLocationIndexed(programID, 0, 1, |
egdaniel | 2d721d3 | 2015-11-11 13:06:05 -0800 | [diff] [blame] | 363 | GrGLSLFragmentShaderBuilder::DeclaredSecondaryColorOutputName())); |
egdaniel | 8dcdedc | 2015-11-11 06:27:20 -0800 | [diff] [blame] | 364 | } |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 365 | |
| 366 | // handle NVPR separable varyings |
| 367 | if (!fGpu->glCaps().shaderCaps()->pathRenderingSupport() || |
| 368 | !fGpu->glPathRendering()->shouldBindFragmentInputs()) { |
| 369 | return; |
| 370 | } |
egdaniel | 0eafe79 | 2015-11-20 14:01:22 -0800 | [diff] [blame] | 371 | int count = fVaryingHandler.fPathProcVaryingInfos.count(); |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 372 | for (int i = 0; i < count; ++i) { |
egdaniel | 0eafe79 | 2015-11-20 14:01:22 -0800 | [diff] [blame] | 373 | GL_CALL(BindFragmentInputLocation(programID, i, |
| 374 | fVaryingHandler.fPathProcVaryingInfos[i].fVariable.c_str())); |
| 375 | fVaryingHandler.fPathProcVaryingInfos[i].fLocation = i; |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 376 | } |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | bool GrGLProgramBuilder::checkLinkStatus(GrGLuint programID) { |
| 380 | GrGLint linked = GR_GL_INIT_ZERO; |
| 381 | GL_CALL(GetProgramiv(programID, GR_GL_LINK_STATUS, &linked)); |
| 382 | if (!linked) { |
Brian Salomon | e334c59 | 2017-05-15 11:00:58 -0400 | [diff] [blame] | 383 | SkDebugf("Program linking failed.\n"); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 384 | GrGLint infoLen = GR_GL_INIT_ZERO; |
| 385 | GL_CALL(GetProgramiv(programID, GR_GL_INFO_LOG_LENGTH, &infoLen)); |
| 386 | SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger |
| 387 | if (infoLen > 0) { |
| 388 | // retrieve length even though we don't need it to workaround |
| 389 | // bug in chrome cmd buffer param validation. |
| 390 | GrGLsizei length = GR_GL_INIT_ZERO; |
| 391 | GL_CALL(GetProgramInfoLog(programID, |
| 392 | infoLen+1, |
| 393 | &length, |
| 394 | (char*)log.get())); |
kkinnunen | 297aaf9 | 2015-02-19 06:32:12 -0800 | [diff] [blame] | 395 | SkDebugf("%s", (char*)log.get()); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 396 | } |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 397 | } |
| 398 | return SkToBool(linked); |
| 399 | } |
| 400 | |
kkinnunen | 7aedda5 | 2015-06-29 23:01:28 -0700 | [diff] [blame] | 401 | void GrGLProgramBuilder::resolveProgramResourceLocations(GrGLuint programID) { |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 402 | fUniformHandler.getUniformLocations(programID, fGpu->glCaps()); |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 403 | |
| 404 | // handle NVPR separable varyings |
| 405 | if (!fGpu->glCaps().shaderCaps()->pathRenderingSupport() || |
kkinnunen | 7bdb05d | 2016-01-25 00:47:23 -0800 | [diff] [blame] | 406 | fGpu->glPathRendering()->shouldBindFragmentInputs()) { |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 407 | return; |
| 408 | } |
egdaniel | 0eafe79 | 2015-11-20 14:01:22 -0800 | [diff] [blame] | 409 | int count = fVaryingHandler.fPathProcVaryingInfos.count(); |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 410 | for (int i = 0; i < count; ++i) { |
| 411 | GrGLint location; |
egdaniel | 0eafe79 | 2015-11-20 14:01:22 -0800 | [diff] [blame] | 412 | GL_CALL_RET(location, GetProgramResourceLocation( |
| 413 | programID, |
| 414 | GR_GL_FRAGMENT_INPUT, |
| 415 | fVaryingHandler.fPathProcVaryingInfos[i].fVariable.c_str())); |
| 416 | fVaryingHandler.fPathProcVaryingInfos[i].fLocation = location; |
joshualitt | d8dd47b | 2015-09-11 11:45:01 -0700 | [diff] [blame] | 417 | } |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 418 | } |
| 419 | |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 420 | void GrGLProgramBuilder::cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs) { |
| 421 | GL_CALL(DeleteProgram(programID)); |
egdaniel | fa89632 | 2016-01-13 12:19:30 -0800 | [diff] [blame] | 422 | this->cleanupShaders(shaderIDs); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 423 | } |
| 424 | void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) { |
| 425 | for (int i = 0; i < shaderIDs.count(); ++i) { |
Brian Salomon | 802cb31 | 2018-06-08 18:05:20 -0400 | [diff] [blame] | 426 | GL_CALL(DeleteShader(shaderIDs[i])); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 427 | } |
| 428 | } |
| 429 | |
| 430 | GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) { |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 431 | return new GrGLProgram(fGpu, |
egdaniel | 7ea439b | 2015-12-03 09:20:44 -0800 | [diff] [blame] | 432 | fUniformHandles, |
| 433 | programID, |
| 434 | fUniformHandler.fUniforms, |
egdaniel | 09aa1fc | 2016-04-20 07:09:46 -0700 | [diff] [blame] | 435 | fUniformHandler.fSamplers, |
egdaniel | 0eafe79 | 2015-11-20 14:01:22 -0800 | [diff] [blame] | 436 | fVaryingHandler.fPathProcVaryingInfos, |
Robert Phillips | 369e8b7 | 2017-08-01 16:13:04 -0400 | [diff] [blame] | 437 | std::move(fGeometryProcessor), |
| 438 | std::move(fXferProcessor), |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 439 | std::move(fFragmentProcessors), |
Brian Salomon | 802cb31 | 2018-06-08 18:05:20 -0400 | [diff] [blame] | 440 | fFragmentProcessorCnt, |
| 441 | std::move(fAttributes), |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 442 | fVertexAttributeCnt, |
| 443 | fInstanceAttributeCnt, |
Brian Salomon | 802cb31 | 2018-06-08 18:05:20 -0400 | [diff] [blame] | 444 | fVertexStride, |
| 445 | fInstanceStride); |
joshualitt | 47bb382 | 2014-10-07 16:43:25 -0700 | [diff] [blame] | 446 | } |