| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "GrGLProgramBuilder.h" |
| #include "gl/GrGLProgram.h" |
| #include "gl/GrGLSLPrettyPrint.h" |
| #include "gl/GrGLUniformHandle.h" |
| #include "../GrGpuGL.h" |
| #include "GrCoordTransform.h" |
| #include "GrGLLegacyNvprProgramBuilder.h" |
| #include "GrGLNvprProgramBuilder.h" |
| #include "GrGLProgramBuilder.h" |
| #include "GrTexture.h" |
| #include "SkRTConf.h" |
| #include "SkTraceEvent.h" |
| |
| #define GL_CALL(X) GR_GL_CALL(this->gpu()->glInterface(), X) |
| #define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X) |
| |
| // ES2 FS only guarantees mediump and lowp support |
| static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| const int GrGLProgramBuilder::kVarsPerBlock = 8; |
| |
| GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState, |
| GrGpu::DrawType drawType, |
| GrGpuGL* gpu) { |
| // create a builder. This will be handed off to effects so they can use it to add |
| // uniforms, varyings, textures, etc |
| SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(optState, |
| drawType, |
| optState.hasGeometryProcessor(), |
| gpu)); |
| |
| GrGLProgramBuilder* pb = builder.get(); |
| const GrGLProgramDescBuilder::GLKeyHeader& header = GrGLProgramDescBuilder::GetHeader(pb->desc()); |
| |
| // emit code to read the dst copy texture, if necessary |
| if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey |
| && !gpu->glCaps().fbFetchSupport()) { |
| pb->fFS.emitCodeToReadDstTexture(); |
| } |
| |
| // get the initial color and coverage to feed into the first effect in each effect chain |
| GrGLSLExpr4 inputColor; |
| GrGLSLExpr1 inputCoverage; |
| pb->setupUniformColorAndCoverageIfNeeded(&inputColor, &inputCoverage); |
| |
| // if we have a vertex shader(we don't only if we are using NVPR or NVPR ES), then we may have |
| // to setup a few more things like builtin vertex attributes |
| bool hasVertexShader = !(header.fUseNvpr && |
| gpu->glPathRendering()->texturingMode() == |
| GrGLPathRendering::FixedFunction_TexturingMode); |
| |
| if (hasVertexShader) { |
| pb->fVS.setupUniformViewMatrix(); |
| pb->fVS.setupPositionAndLocalCoords(); |
| |
| if (header.fEmitsPointSize) { |
| pb->fVS.codeAppend("gl_PointSize = 1.0;"); |
| } |
| if (GrProgramDesc::kAttribute_ColorInput == header.fColorInput) { |
| pb->fVS.setupBuiltinVertexAttribute("Color", &inputColor); |
| } |
| if (GrProgramDesc::kAttribute_ColorInput == header.fCoverageInput) { |
| pb->fVS.setupBuiltinVertexAttribute("Coverage", &inputCoverage); |
| } |
| } |
| |
| // TODO: Once all stages can handle taking a float or vec4 and correctly handling them we can |
| // remove this cast to a vec4. |
| GrGLSLExpr4 inputCoverageVec4 = GrGLSLExpr4::VectorCast(inputCoverage); |
| |
| pb->emitAndInstallProcs(&inputColor, &inputCoverageVec4); |
| |
| if (hasVertexShader) { |
| pb->fVS.transformToNormalizedDeviceSpace(); |
| } |
| |
| // write the secondary color output if necessary |
| if (GrProgramDesc::kNone_SecondaryOutputType != header.fSecondaryOutputType) { |
| pb->fFS.enableSecondaryOutput(inputColor, inputCoverageVec4); |
| } |
| |
| pb->fFS.combineColorAndCoverage(inputColor, inputCoverageVec4); |
| |
| return pb->finalize(); |
| } |
| |
| GrGLProgramBuilder* |
| GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState, |
| GrGpu::DrawType drawType, |
| bool hasGeometryProcessor, |
| GrGpuGL* gpu) { |
| const GrProgramDesc& desc = optState.programDesc(); |
| if (GrGLProgramDescBuilder::GetHeader(desc).fUseNvpr) { |
| SkASSERT(gpu->glCaps().pathRenderingSupport()); |
| SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fColorInput); |
| SkASSERT(GrProgramDesc::kAttribute_ColorInput != desc.header().fCoverageInput); |
| SkASSERT(!hasGeometryProcessor); |
| if (gpu->glPathRendering()->texturingMode() == |
| GrGLPathRendering::FixedFunction_TexturingMode) { |
| return SkNEW_ARGS(GrGLLegacyNvprProgramBuilder, (gpu, optState)); |
| } else { |
| return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, optState)); |
| } |
| } else { |
| return SkNEW_ARGS(GrGLProgramBuilder, (gpu, optState)); |
| } |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| |
| GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu, const GrOptDrawState& optState) |
| : fVS(this) |
| , fGS(this) |
| , fFS(this, optState.programDesc().header().fFragPosKey) |
| , fOutOfStage(true) |
| , fStageIndex(-1) |
| , fGeometryProcessor(NULL) |
| , fOptState(optState) |
| , fDesc(optState.programDesc()) |
| , fGpu(gpu) |
| , fUniforms(kVarsPerBlock) { |
| } |
| |
| void GrGLProgramBuilder::addVarying(const char* name, |
| GrGLVarying* varying, |
| GrGLShaderVar::Precision fsPrecision) { |
| SkASSERT(varying); |
| if (varying->vsVarying()) { |
| fVS.addVarying(name, varying); |
| } |
| if (fOptState.hasGeometryProcessor() && fOptState.getGeometryProcessor()->willUseGeoShader()) { |
| fGS.addVarying(name, varying); |
| } |
| if (varying->fsVarying()) { |
| fFS.addVarying(varying, fsPrecision); |
| } |
| } |
| |
| void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name) { |
| if ('\0' == prefix) { |
| *out = name; |
| } else { |
| out->printf("%c%s", prefix, name); |
| } |
| if (!fOutOfStage) { |
| if (out->endsWith('_')) { |
| // Names containing "__" are reserved. |
| out->append("x"); |
| } |
| out->appendf("_Stage%d", fStageIndex); |
| } |
| } |
| |
| GrGLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(uint32_t visibility, |
| GrSLType type, |
| const char* name, |
| int count, |
| const char** outName) { |
| SkASSERT(name && strlen(name)); |
| SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility); |
| SkASSERT(0 == (~kVisibilityMask & visibility)); |
| SkASSERT(0 != visibility); |
| |
| UniformInfo& uni = fUniforms.push_back(); |
| uni.fVariable.setType(type); |
| uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier); |
| // TODO this is a bit hacky, lets think of a better way. Basically we need to be able to use |
| // the uniform view matrix name in the GP, and the GP is immutable so it has to tell the PB |
| // exactly what name it wants to use for the uniform view matrix. If we prefix anythings, then |
| // the names will mismatch. I think the correct solution is to have all GPs which need the |
| // uniform view matrix, they should upload the view matrix in their setData along with regular |
| // uniforms. |
| char prefix = 'u'; |
| if ('u' == name[0]) { |
| prefix = '\0'; |
| } |
| this->nameVariable(uni.fVariable.accessName(), prefix, name); |
| uni.fVariable.setArrayCount(count); |
| uni.fVisibility = visibility; |
| |
| // If it is visible in both the VS and FS, the precision must match. |
| // We declare a default FS precision, but not a default VS. So set the var |
| // to use the default FS precision. |
| if ((kVertex_Visibility | kFragment_Visibility) == visibility) { |
| // the fragment and vertex precisions must match |
| uni.fVariable.setPrecision(kDefaultFragmentPrecision); |
| } |
| |
| if (outName) { |
| *outName = uni.fVariable.c_str(); |
| } |
| return GrGLProgramDataManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1); |
| } |
| |
| void GrGLProgramBuilder::appendUniformDecls(ShaderVisibility visibility, |
| SkString* out) const { |
| for (int i = 0; i < fUniforms.count(); ++i) { |
| if (fUniforms[i].fVisibility & visibility) { |
| fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out); |
| out->append(";\n"); |
| } |
| } |
| } |
| |
| const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const { |
| return fGpu->ctxInfo(); |
| } |
| |
| void GrGLProgramBuilder::setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor, |
| GrGLSLExpr1* inputCoverage) { |
| const GrProgramDesc::KeyHeader& header = this->header(); |
| if (GrProgramDesc::kUniform_ColorInput == header.fColorInput) { |
| const char* name; |
| fUniformHandles.fColorUni = |
| this->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
| kVec4f_GrSLType, |
| "Color", |
| &name); |
| *inputColor = GrGLSLExpr4(name); |
| } else if (GrProgramDesc::kAllOnes_ColorInput == header.fColorInput) { |
| *inputColor = GrGLSLExpr4(1); |
| } |
| if (GrProgramDesc::kUniform_ColorInput == header.fCoverageInput) { |
| const char* name; |
| fUniformHandles.fCoverageUni = |
| this->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
| kFloat_GrSLType, |
| "Coverage", |
| &name); |
| *inputCoverage = GrGLSLExpr1(name); |
| } else if (GrProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) { |
| *inputCoverage = GrGLSLExpr1(1); |
| } |
| } |
| |
| void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, |
| GrGLSLExpr4* inputCoverage) { |
| fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs)); |
| int numProcs = fOptState.numFragmentStages(); |
| this->emitAndInstallFragProcs(0, fOptState.numColorStages(), inputColor); |
| if (fOptState.hasGeometryProcessor()) { |
| const GrGeometryProcessor& gp = *fOptState.getGeometryProcessor(); |
| fVS.emitAttributes(gp); |
| GrGLSLExpr4 output; |
| this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, *inputCoverage, &output); |
| *inputCoverage = output; |
| } |
| this->emitAndInstallFragProcs(fOptState.numColorStages(), numProcs, inputCoverage); |
| } |
| |
| void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut) { |
| for (int e = procOffset; e < numProcs; ++e) { |
| GrGLSLExpr4 output; |
| const GrPendingFragmentStage& stage = fOptState.getFragmentStage(e); |
| this->emitAndInstallProc<GrPendingFragmentStage>(stage, e, *inOut, &output); |
| *inOut = output; |
| } |
| } |
| |
| // TODO Processors cannot output zeros because an empty string is all 1s |
| // the fix is to allow effects to take the GrGLSLExpr4 directly |
| template <class Proc> |
| void GrGLProgramBuilder::emitAndInstallProc(const Proc& proc, |
| int index, |
| const GrGLSLExpr4& input, |
| GrGLSLExpr4* output) { |
| // Program builders have a bit of state we need to clear with each effect |
| AutoStageAdvance adv(this); |
| |
| // create var to hold stage result. If we already have a valid output name, just use that |
| // otherwise create a new mangled one. |
| SkString outColorName; |
| if (output->isValid()) { |
| outColorName = output->c_str(); |
| } else { |
| this->nameVariable(&outColorName, '\0', "output"); |
| } |
| fFS.codeAppendf("vec4 %s;", outColorName.c_str()); |
| *output = outColorName; |
| |
| // Enclose custom code in a block to avoid namespace conflicts |
| SkString openBrace; |
| openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name()); |
| fFS.codeAppend(openBrace.c_str()); |
| |
| this->emitAndInstallProc(proc, output->c_str(), input.isOnes() ? NULL : input.c_str()); |
| |
| fFS.codeAppend("}"); |
| } |
| |
| void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& fs, |
| const char* outColor, |
| const char* inColor) { |
| GrGLInstalledFragProc* ifp = SkNEW_ARGS(GrGLInstalledFragProc, (fVS.hasLocalCoords())); |
| |
| const GrFragmentProcessor& fp = *fs.getProcessor(); |
| ifp->fGLProc.reset(fp.getFactory().createGLInstance(fp)); |
| |
| SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTextures()); |
| this->emitSamplers(fp, &samplers, ifp); |
| |
| // Fragment processors can have coord transforms |
| SkSTArray<2, GrGLProcessor::TransformedCoords> coords(fp.numTransforms()); |
| this->emitTransforms(fs, &coords, ifp); |
| |
| ifp->fGLProc->emitCode(this, fp, outColor, inColor, coords, samplers); |
| |
| // We have to check that effects and the code they emit are consistent, ie if an effect |
| // asks for dst color, then the emit code needs to follow suit |
| verify(fp); |
| fFragmentProcessors->fProcs.push_back(ifp); |
| } |
| |
| void GrGLProgramBuilder::emitAndInstallProc(const GrGeometryProcessor& gp, |
| const char* outCoverage, |
| const char* inCoverage) { |
| SkASSERT(!fGeometryProcessor); |
| fGeometryProcessor = SkNEW(GrGLInstalledGeoProc); |
| |
| fGeometryProcessor->fGLProc.reset(gp.getFactory().createGLInstance(gp)); |
| |
| SkSTArray<4, GrGLProcessor::TextureSampler> samplers(gp.numTextures()); |
| this->emitSamplers(gp, &samplers, fGeometryProcessor); |
| |
| GrGLGeometryProcessor::EmitArgs args(this, gp, outCoverage, inCoverage, samplers); |
| fGeometryProcessor->fGLProc->emitCode(args); |
| |
| // We have to check that effects and the code they emit are consistent, ie if an effect |
| // asks for dst color, then the emit code needs to follow suit |
| verify(gp); |
| } |
| |
| void GrGLProgramBuilder::verify(const GrGeometryProcessor& gp) { |
| SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition()); |
| } |
| |
| void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) { |
| SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition()); |
| SkASSERT(fFS.hasReadDstColor() == fp.willReadDstColor()); |
| } |
| |
| void GrGLProgramBuilder::emitTransforms(const GrPendingFragmentStage& stage, |
| GrGLProcessor::TransformedCoordsArray* outCoords, |
| GrGLInstalledFragProc* ifp) { |
| const GrFragmentProcessor* processor = stage.getProcessor(); |
| int numTransforms = processor->numTransforms(); |
| ifp->fTransforms.push_back_n(numTransforms); |
| |
| for (int t = 0; t < numTransforms; t++) { |
| const char* uniName = "StageMatrix"; |
| GrSLType varyingType = stage.isPerspectiveCoordTransform(t) ? kVec3f_GrSLType : |
| kVec2f_GrSLType; |
| SkString suffixedUniName; |
| if (0 != t) { |
| suffixedUniName.append(uniName); |
| suffixedUniName.appendf("_%i", t); |
| uniName = suffixedUniName.c_str(); |
| } |
| ifp->fTransforms[t].fHandle = this->addUniform(GrGLProgramBuilder::kVertex_Visibility, |
| kMat33f_GrSLType, |
| uniName, |
| &uniName).toShaderBuilderIndex(); |
| |
| const char* varyingName = "MatrixCoord"; |
| SkString suffixedVaryingName; |
| if (0 != t) { |
| suffixedVaryingName.append(varyingName); |
| suffixedVaryingName.appendf("_%i", t); |
| varyingName = suffixedVaryingName.c_str(); |
| } |
| const char* coords = kPosition_GrCoordSet == processor->coordTransform(t).sourceCoords() ? |
| fVS.positionAttribute().c_str() : |
| fVS.localCoordsAttribute().c_str(); |
| GrGLVertToFrag v(varyingType); |
| this->addCoordVarying(varyingName, &v, uniName, coords); |
| |
| SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType); |
| SkNEW_APPEND_TO_TARRAY(outCoords, GrGLProcessor::TransformedCoords, |
| (SkString(v.fsIn()), varyingType)); |
| } |
| } |
| |
| void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor, |
| GrGLProcessor::TextureSamplerArray* outSamplers, |
| GrGLInstalledProc* ip) { |
| int numTextures = processor.numTextures(); |
| ip->fSamplers.push_back_n(numTextures); |
| SkString name; |
| for (int t = 0; t < numTextures; ++t) { |
| name.printf("Sampler%d", t); |
| ip->fSamplers[t].fUniform = this->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
| kSampler2D_GrSLType, |
| name.c_str()); |
| SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler, |
| (ip->fSamplers[t].fUniform, processor.textureAccess(t))); |
| } |
| } |
| |
| GrGLProgram* GrGLProgramBuilder::finalize() { |
| // verify we can get a program id |
| GrGLuint programID; |
| GL_CALL_RET(programID, CreateProgram()); |
| if (0 == programID) { |
| return NULL; |
| } |
| |
| // compile shaders and bind attributes / uniforms |
| SkTDArray<GrGLuint> shadersToDelete; |
| if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) { |
| this->cleanupProgram(programID, shadersToDelete); |
| return NULL; |
| } |
| if (!(GrGLProgramDescBuilder::GetHeader(fDesc).fUseNvpr && |
| fGpu->glPathRendering()->texturingMode() == |
| GrGLPathRendering::FixedFunction_TexturingMode)) { |
| if (!fVS.compileAndAttachShaders(programID, &shadersToDelete)) { |
| this->cleanupProgram(programID, shadersToDelete); |
| return NULL; |
| } |
| fVS.bindVertexAttributes(programID); |
| } |
| bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL; |
| if (usingBindUniform) { |
| this->bindUniformLocations(programID); |
| } |
| fFS.bindFragmentShaderLocations(programID); |
| GL_CALL(LinkProgram(programID)); |
| |
| // Calling GetProgramiv is expensive in Chromium. Assume success in release builds. |
| bool checkLinked = !fGpu->ctxInfo().isChromium(); |
| #ifdef SK_DEBUG |
| checkLinked = true; |
| #endif |
| if (checkLinked) { |
| checkLinkStatus(programID); |
| } |
| if (!usingBindUniform) { |
| this->resolveUniformLocations(programID); |
| } |
| |
| this->cleanupShaders(shadersToDelete); |
| |
| return this->createProgram(programID); |
| } |
| |
| void GrGLProgramBuilder::bindUniformLocations(GrGLuint programID) { |
| int count = fUniforms.count(); |
| for (int i = 0; i < count; ++i) { |
| GL_CALL(BindUniformLocation(programID, i, fUniforms[i].fVariable.c_str())); |
| fUniforms[i].fLocation = i; |
| } |
| } |
| |
| bool GrGLProgramBuilder::checkLinkStatus(GrGLuint programID) { |
| GrGLint linked = GR_GL_INIT_ZERO; |
| GL_CALL(GetProgramiv(programID, GR_GL_LINK_STATUS, &linked)); |
| if (!linked) { |
| GrGLint infoLen = GR_GL_INIT_ZERO; |
| GL_CALL(GetProgramiv(programID, GR_GL_INFO_LOG_LENGTH, &infoLen)); |
| SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger |
| if (infoLen > 0) { |
| // retrieve length even though we don't need it to workaround |
| // bug in chrome cmd buffer param validation. |
| GrGLsizei length = GR_GL_INIT_ZERO; |
| GL_CALL(GetProgramInfoLog(programID, |
| infoLen+1, |
| &length, |
| (char*)log.get())); |
| SkDebugf((char*)log.get()); |
| } |
| SkDEBUGFAIL("Error linking program"); |
| GL_CALL(DeleteProgram(programID)); |
| programID = 0; |
| } |
| return SkToBool(linked); |
| } |
| |
| void GrGLProgramBuilder::resolveUniformLocations(GrGLuint programID) { |
| int count = fUniforms.count(); |
| for (int i = 0; i < count; ++i) { |
| GrGLint location; |
| GL_CALL_RET(location, GetUniformLocation(programID, fUniforms[i].fVariable.c_str())); |
| fUniforms[i].fLocation = location; |
| } |
| } |
| |
| void GrGLProgramBuilder::cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs) { |
| GL_CALL(DeleteProgram(programID)); |
| cleanupShaders(shaderIDs); |
| } |
| void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) { |
| for (int i = 0; i < shaderIDs.count(); ++i) { |
| GL_CALL(DeleteShader(shaderIDs[i])); |
| } |
| } |
| |
| GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) { |
| return SkNEW_ARGS(GrGLProgram, (fGpu, fDesc, fUniformHandles, programID, fUniforms, |
| fGeometryProcessor, fFragmentProcessors.get())); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| GrGLInstalledFragProcs::~GrGLInstalledFragProcs() { |
| int numProcs = fProcs.count(); |
| for (int e = 0; e < numProcs; ++e) { |
| SkDELETE(fProcs[e]); |
| } |
| } |