src/gpu/gl/GrGLShaderBuilder.cpp - Issue 491673002: Initial refactor of shaderbuilder

Unified Diff: src/gpu/gl/GrGLShaderBuilder.cpp

Issue 491673002: Initial refactor of shaderbuilder (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: rebase Created 6 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: src/gpu/gl/GrGLShaderBuilder.cpp

diff --git a/src/gpu/gl/GrGLShaderBuilder.cpp b/src/gpu/gl/GrGLShaderBuilder.cpp

deleted file mode 100644

index 9fffd26145d9fd299ffa0e4785b4bbe0af8cdaae..0000000000000000000000000000000000000000

--- a/src/gpu/gl/GrGLShaderBuilder.cpp

+++ /dev/null

@@ -1,1071 +0,0 @@

-/*

- *

- * Use of this source code is governed by a BSD-style license that can be

- * found in the LICENSE file.

- */

-#include "gl/GrGLShaderBuilder.h"

-#include "gl/GrGLProgram.h"

-#include "gl/GrGLSLPrettyPrint.h"

-#include "gl/GrGLUniformHandle.h"

-#include "GrCoordTransform.h"

-#include "GrDrawEffect.h"

-#include "GrGpuGL.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)

-// number of each input/output type in a single allocation block

-static const int kVarsPerBlock = 8;

-// except FS outputs where we expect 2 at most.

-static const int kMaxFSOutputs = 2;

-// ES2 FS only guarantees mediump and lowp support

-static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;

-typedef GrGLProgramDataManager::UniformHandle UniformHandle;

-SK_CONF_DECLARE(bool, c_PrintShaders, "gpu.printShaders", false,

- "Print the source code for all shaders generated.");

-///////////////////////////////////////////////////////////////////////////////

-namespace {

-inline const char* color_attribute_name() { return "aColor"; }

-inline const char* coverage_attribute_name() { return "aCoverage"; }

-inline const char* declared_color_output_name() { return "fsColorOut"; }

-inline const char* dual_source_output_name() { return "dualSourceOut"; }

-inline const char* sample_function_name(GrSLType type, GrGLSLGeneration glslGen) {

- if (kVec2f_GrSLType == type) {

- return glslGen >= k130_GrGLSLGeneration ? "texture" : "texture2D";

- } else {

- SkASSERT(kVec3f_GrSLType == type);

- return glslGen >= k130_GrGLSLGeneration ? "textureProj" : "texture2DProj";

- }

-void append_texture_lookup(SkString* out,

- GrGpuGL* gpu,

- const char* samplerName,

- const char* coordName,

- uint32_t configComponentMask,

- const char* swizzle,

- GrSLType varyingType = kVec2f_GrSLType) {

- SkASSERT(NULL != coordName);

- out->appendf("%s(%s, %s)",

- sample_function_name(varyingType, gpu->glslGeneration()),

- samplerName,

- coordName);

- char mangledSwizzle[5];

- // The swizzling occurs using texture params instead of shader-mangling if ARB_texture_swizzle

- // is available.

- if (!gpu->glCaps().textureSwizzleSupport() &&

- (kA_GrColorComponentFlag == configComponentMask)) {

- char alphaChar = gpu->glCaps().textureRedSupport() ? 'r' : 'a';

- int i;

- for (i = 0; '\0' != swizzle[i]; ++i) {

- mangledSwizzle[i] = alphaChar;

- }

- mangledSwizzle[i] ='\0';

- swizzle = mangledSwizzle;

- }

- // For shader prettiness we omit the swizzle rather than appending ".rgba".

- if (memcmp(swizzle, "rgba", 4)) {

- out->appendf(".%s", swizzle);

- }

-static const char kDstCopyColorName[] = "_dstColor";

-///////////////////////////////////////////////////////////////////////////////

-bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],

- const GrEffectStage* coverageStages[]) {

- const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();

- ///////////////////////////////////////////////////////////////////////////

- // emit code to read the dst copy texture, if necessary

- if (kNoDstRead_DstReadKey != header.fDstReadKey && !fGpu->glCaps().fbFetchSupport()) {

- bool topDown = SkToBool(kTopLeftOrigin_DstReadKeyBit & header.fDstReadKey);

- const char* dstCopyTopLeftName;

- const char* dstCopyCoordScaleName;

- const char* dstCopySamplerName;

- uint32_t configMask;

- if (SkToBool(kUseAlphaConfig_DstReadKeyBit & header.fDstReadKey)) {

- configMask = kA_GrColorComponentFlag;

- } else {

- configMask = kRGBA_GrColorComponentFlags;

- }

- fUniformHandles.fDstCopySamplerUni =

- this->addUniform(kFragment_Visibility, kSampler2D_GrSLType, "DstCopySampler",

- &dstCopySamplerName);

- fUniformHandles.fDstCopyTopLeftUni =

- this->addUniform(kFragment_Visibility, kVec2f_GrSLType, "DstCopyUpperLeft",

- &dstCopyTopLeftName);

- fUniformHandles.fDstCopyScaleUni =

- this->addUniform(kFragment_Visibility, kVec2f_GrSLType, "DstCopyCoordScale",

- &dstCopyCoordScaleName);

- const char* fragPos = this->fragmentPosition();

- this->fsCodeAppend("\t// Read color from copy of the destination.\n");

- this->fsCodeAppendf("\tvec2 _dstTexCoord = (%s.xy - %s) * %s;\n",

- fragPos, dstCopyTopLeftName, dstCopyCoordScaleName);

- if (!topDown) {

- this->fsCodeAppend("\t_dstTexCoord.y = 1.0 - _dstTexCoord.y;\n");

- }

- this->fsCodeAppendf("\tvec4 %s = ", kDstCopyColorName);

- append_texture_lookup(&fFSCode,

- fGpu,

- dstCopySamplerName,

- "_dstTexCoord",

- configMask,

- "rgba");

- this->fsCodeAppend(";\n\n");

- }

- ///////////////////////////////////////////////////////////////////////////

- // get the initial color and coverage to feed into the first effect in each effect chain

- GrGLSLExpr4 inputColor;

- GrGLSLExpr4 inputCoverage;

- if (GrGLProgramDesc::kUniform_ColorInput == header.fColorInput) {

- const char* name;

- fUniformHandles.fColorUni =

- this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Color",

- &name);

- inputColor = GrGLSLExpr4(name);

- }

- if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {

- const char* name;

- fUniformHandles.fCoverageUni =

- this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Coverage",

- &name);

- inputCoverage = GrGLSLExpr4(name);

- } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {

- inputCoverage = GrGLSLExpr4(1);

- }

- if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {

- fFSOutputs.push_back().set(kVec4f_GrSLType,

- GrGLShaderVar::kOut_TypeModifier,

- declared_color_output_name());

- fHasCustomColorOutput = true;

- }

- this->emitCodeBeforeEffects(&inputColor, &inputCoverage);

- ///////////////////////////////////////////////////////////////////////////

- // emit the per-effect code for both color and coverage effects

- GrGLProgramDesc::EffectKeyProvider colorKeyProvider(

- &this->desc(), GrGLProgramDesc::EffectKeyProvider::kColor_EffectType);

- fColorEffects.reset(this->createAndEmitEffects(colorStages,

- this->desc().numColorEffects(),

- colorKeyProvider,

- &inputColor));

- GrGLProgramDesc::EffectKeyProvider coverageKeyProvider(

- &this->desc(), GrGLProgramDesc::EffectKeyProvider::kCoverage_EffectType);

- fCoverageEffects.reset(this->createAndEmitEffects(coverageStages,

- this->desc().numCoverageEffects(),

- coverageKeyProvider,

- &inputCoverage));

- this->emitCodeAfterEffects();

- ///////////////////////////////////////////////////////////////////////////

- // write the secondary color output if necessary

- if (GrGLProgramDesc::CoverageOutputUsesSecondaryOutput(header.fCoverageOutput)) {

- const char* secondaryOutputName = this->enableSecondaryOutput();

- // default coeff to ones for kCoverage_DualSrcOutput

- GrGLSLExpr4 coeff(1);

- if (GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput == header.fCoverageOutput) {

- // Get (1-A) into coeff

- coeff = GrGLSLExpr4::VectorCast(GrGLSLExpr1(1) - inputColor.a());

- } else if (GrGLProgramDesc::kSecondaryCoverageISC_CoverageOutput ==

- header.fCoverageOutput){

- // Get (1-RGBA) into coeff

- coeff = GrGLSLExpr4(1) - inputColor;

- }

- // Get coeff * coverage into modulate and then write that to the dual source output.

- this->fsCodeAppendf("\t%s = %s;\n", secondaryOutputName, (coeff * inputCoverage).c_str());

- }

- ///////////////////////////////////////////////////////////////////////////

- // combine color and coverage as frag color

- // Get "color * coverage" into fragColor

- GrGLSLExpr4 fragColor = inputColor * inputCoverage;

- // Now tack on "+(1-coverage)dst onto the frag color if we were asked to do so.

- if (GrGLProgramDesc::kCombineWithDst_CoverageOutput == header.fCoverageOutput) {

- GrGLSLExpr4 dstCoeff = GrGLSLExpr4(1) - inputCoverage;

- GrGLSLExpr4 dstContribution = dstCoeff * GrGLSLExpr4(this->dstColor());

- fragColor = fragColor + dstContribution;

- }

- this->fsCodeAppendf("\t%s = %s;\n", this->getColorOutputName(), fragColor.c_str());

- if (!this->finish()) {

- return false;

- }

- return true;

-//////////////////////////////////////////////////////////////////////////////

-GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,

- const GrGLProgramDesc& desc)

- : fHasVertexShader(false)

- , fTexCoordSetCnt(0)

- , fProgramID(0)

- , fDesc(desc)

- , fGpu(gpu)

- , fFSFeaturesAddedMask(0)

- , fFSInputs(kVarsPerBlock)

- , fFSOutputs(kMaxFSOutputs)

- , fUniforms(kVarsPerBlock)

- , fSetupFragPosition(false)

- , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey)

- , fHasCustomColorOutput(false)

- , fHasSecondaryOutput(false) {

-bool GrGLShaderBuilder::enableFeature(GLSLFeature feature) {

- switch (feature) {

- case kStandardDerivatives_GLSLFeature:

- if (!fGpu->glCaps().shaderDerivativeSupport()) {

- return false;

- }

- if (kGLES_GrGLStandard == fGpu->glStandard()) {

- this->addFSFeature(1 << kStandardDerivatives_GLSLFeature,

- "GL_OES_standard_derivatives");

- }

- return true;

- default:

- SkFAIL("Unexpected GLSLFeature requested.");

- return false;

- }

-void GrGLShaderBuilder::addFSFeature(uint32_t featureBit, const char* extensionName) {

- if (!(featureBit & fFSFeaturesAddedMask)) {

- fFSExtensions.appendf("#extension %s: require\n", extensionName);

- fFSFeaturesAddedMask |= featureBit;

- }

-void GrGLShaderBuilder::nameVariable(SkString* out, char prefix, const char* name) {

- if ('\0' == prefix) {

- *out = name;

- } else {

- out->printf("%c%s", prefix, name);

- }

- if (fCodeStage.inStageCode()) {

- if (out->endsWith('_')) {

- // Names containing "__" are reserved.

- out->append("x");

- }

- out->appendf("_Stage%d", fCodeStage.stageIndex());

- }

-const char* GrGLShaderBuilder::dstColor() {

- if (fCodeStage.inStageCode()) {

- const GrEffect* effect = fCodeStage.effectStage()->getEffect();

- if (!effect->willReadDstColor()) {

- SkDEBUGFAIL("GrGLEffect asked for dst color but its generating GrEffect "

- "did not request access.");

- return "";

- }

- if (fGpu->glCaps().fbFetchSupport()) {

- this->addFSFeature(1 << (kLastGLSLPrivateFeature + 1),

- fGpu->glCaps().fbFetchExtensionString());

- return fGpu->glCaps().fbFetchColorName();

- } else if (fUniformHandles.fDstCopySamplerUni.isValid()) {

- return kDstCopyColorName;

- } else {

- return "";

- }

-void GrGLShaderBuilder::appendTextureLookup(SkString* out,

- const GrGLShaderBuilder::TextureSampler& sampler,

- const char* coordName,

- GrSLType varyingType) const {

- append_texture_lookup(out,

- fGpu,

- this->getUniformCStr(sampler.samplerUniform()),

- coordName,

- sampler.configComponentMask(),

- sampler.swizzle(),

- varyingType);

-void GrGLShaderBuilder::fsAppendTextureLookup(const GrGLShaderBuilder::TextureSampler& sampler,

- const char* coordName,

- GrSLType varyingType) {

- this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);

-void GrGLShaderBuilder::fsAppendTextureLookupAndModulate(

- const char* modulation,

- const GrGLShaderBuilder::TextureSampler& sampler,

- const char* coordName,

- GrSLType varyingType) {

- SkString lookup;

- this->appendTextureLookup(&lookup, sampler, coordName, varyingType);

- fFSCode.append((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());

-GrGLShaderBuilder::DstReadKey GrGLShaderBuilder::KeyForDstRead(const GrTexture* dstCopy,

- const GrGLCaps& caps) {

- uint32_t key = kYesDstRead_DstReadKeyBit;

- if (caps.fbFetchSupport()) {

- return key;

- }

- SkASSERT(NULL != dstCopy);

- if (!caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(dstCopy->config())) {

- // The fact that the config is alpha-only must be considered when generating code.

- key |= kUseAlphaConfig_DstReadKeyBit;

- }

- if (kTopLeft_GrSurfaceOrigin == dstCopy->origin()) {

- key |= kTopLeftOrigin_DstReadKeyBit;

- }

- SkASSERT(static_cast<DstReadKey>(key) == key);

- return static_cast<DstReadKey>(key);

-GrGLShaderBuilder::FragPosKey GrGLShaderBuilder::KeyForFragmentPosition(const GrRenderTarget* dst,

- const GrGLCaps&) {

- if (kTopLeft_GrSurfaceOrigin == dst->origin()) {

- return kTopLeftFragPosRead_FragPosKey;

- } else {

- return kBottomLeftFragPosRead_FragPosKey;

- }

-const GrGLenum* GrGLShaderBuilder::GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps) {

- if (caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(config)) {

- if (caps.textureRedSupport()) {

- static const GrGLenum gRedSmear[] = { GR_GL_RED, GR_GL_RED, GR_GL_RED, GR_GL_RED };

- return gRedSmear;

- } else {

- static const GrGLenum gAlphaSmear[] = { GR_GL_ALPHA, GR_GL_ALPHA,

- GR_GL_ALPHA, GR_GL_ALPHA };

- return gAlphaSmear;

- }

- } else {

- static const GrGLenum gStraight[] = { GR_GL_RED, GR_GL_GREEN, GR_GL_BLUE, GR_GL_ALPHA };

- return gStraight;

- }

-GrGLProgramDataManager::UniformHandle GrGLShaderBuilder::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);

- this->nameVariable(uni.fVariable.accessName(), 'u', 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 (NULL != outName) {

- *outName = uni.fVariable.c_str();

- }

- return GrGLProgramDataManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);

-SkString GrGLShaderBuilder::ensureFSCoords2D(const TransformedCoordsArray& coords, int index) {

- if (kVec3f_GrSLType != coords[index].type()) {

- SkASSERT(kVec2f_GrSLType == coords[index].type());

- return coords[index].getName();

- }

- SkString coords2D("coords2D");

- if (0 != index) {

- coords2D.appendf("_%i", index);

- }

- this->fsCodeAppendf("\tvec2 %s = %s.xy / %s.z;",

- coords2D.c_str(), coords[index].c_str(), coords[index].c_str());

- return coords2D;

-const char* GrGLShaderBuilder::fragmentPosition() {

- if (fCodeStage.inStageCode()) {

- const GrEffect* effect = fCodeStage.effectStage()->getEffect();

- if (!effect->willReadFragmentPosition()) {

- SkDEBUGFAIL("GrGLEffect asked for frag position but its generating GrEffect "

- "did not request access.");

- return "";

- }

- // We only declare "gl_FragCoord" when we're in the case where we want to use layout qualifiers

- // to reverse y. Otherwise it isn't necessary and whether the "in" qualifier appears in the

- // declaration varies in earlier GLSL specs. So it is simpler to omit it.

- if (fTopLeftFragPosRead) {

- fSetupFragPosition = true;

- return "gl_FragCoord";

- } else if (fGpu->glCaps().fragCoordConventionsSupport()) {

- if (!fSetupFragPosition) {

- if (fGpu->glslGeneration() < k150_GrGLSLGeneration) {

- this->addFSFeature(1 << kFragCoordConventions_GLSLPrivateFeature,

- "GL_ARB_fragment_coord_conventions");

- }

- fFSInputs.push_back().set(kVec4f_GrSLType,

- GrGLShaderVar::kIn_TypeModifier,

- "gl_FragCoord",

- GrGLShaderVar::kDefault_Precision,

- GrGLShaderVar::kUpperLeft_Origin);

- fSetupFragPosition = true;

- }

- return "gl_FragCoord";

- } else {

- static const char* kCoordName = "fragCoordYDown";

- if (!fSetupFragPosition) {

- // temporarily change the stage index because we're inserting non-stage code.

- CodeStage::AutoStageRestore csar(&fCodeStage, NULL);

- SkASSERT(!fUniformHandles.fRTHeightUni.isValid());

- const char* rtHeightName;

- fUniformHandles.fRTHeightUni =

- this->addUniform(kFragment_Visibility, kFloat_GrSLType, "RTHeight", &rtHeightName);

- // Using glFragCoord.zw for the last two components tickles an Adreno driver bug that

- // causes programs to fail to link. Making this function return a vec2() didn't fix the

- // problem but using 1.0 for the last two components does.

- this->fFSCode.prependf("\tvec4 %s = vec4(gl_FragCoord.x, %s - gl_FragCoord.y, 1.0, "

- "1.0);\n", kCoordName, rtHeightName);

- fSetupFragPosition = true;

- }

- SkASSERT(fUniformHandles.fRTHeightUni.isValid());

- return kCoordName;

- }

-void GrGLShaderBuilder::fsEmitFunction(GrSLType returnType,

- const char* name,

- int argCnt,

- const GrGLShaderVar* args,

- const char* body,

- SkString* outName) {

- fFSFunctions.append(GrGLSLTypeString(returnType));

- this->nameVariable(outName, '\0', name);

- fFSFunctions.appendf(" %s", outName->c_str());

- fFSFunctions.append("(");

- for (int i = 0; i < argCnt; ++i) {

- args[i].appendDecl(this->ctxInfo(), &fFSFunctions);

- if (i < argCnt - 1) {

- fFSFunctions.append(", ");

- }

- fFSFunctions.append(") {\n");

- fFSFunctions.append(body);

- fFSFunctions.append("}\n\n");

-namespace {

-inline void append_default_precision_qualifier(GrGLShaderVar::Precision p,

- GrGLStandard standard,

- SkString* str) {

- // Desktop GLSL has added precision qualifiers but they don't do anything.

- if (kGLES_GrGLStandard == standard) {

- switch (p) {

- case GrGLShaderVar::kHigh_Precision:

- str->append("precision highp float;\n");

- break;

- case GrGLShaderVar::kMedium_Precision:

- str->append("precision mediump float;\n");

- break;

- case GrGLShaderVar::kLow_Precision:

- str->append("precision lowp float;\n");

- break;

- case GrGLShaderVar::kDefault_Precision:

- SkFAIL("Default precision now allowed.");

- default:

- SkFAIL("Unknown precision value.");

- }

-void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {

- for (int i = 0; i < vars.count(); ++i) {

- vars[i].appendDecl(this->ctxInfo(), out);

- out->append(";\n");

- }

-void GrGLShaderBuilder::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");

- }

-void GrGLShaderBuilder::createAndEmitEffects(GrGLProgramEffectsBuilder* programEffectsBuilder,

- const GrEffectStage* effectStages[],

- int effectCnt,

- const GrGLProgramDesc::EffectKeyProvider& keyProvider,

- GrGLSLExpr4* fsInOutColor) {

- bool effectEmitted = false;

- GrGLSLExpr4 inColor = *fsInOutColor;

- GrGLSLExpr4 outColor;

- for (int e = 0; e < effectCnt; ++e) {

- SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());

- const GrEffectStage& stage = *effectStages[e];

- CodeStage::AutoStageRestore csar(&fCodeStage, &stage);

- if (inColor.isZeros()) {

- SkString inColorName;

- // Effects have no way to communicate zeros, they treat an empty string as ones.

- this->nameVariable(&inColorName, '\0', "input");

- this->fsCodeAppendf("\tvec4 %s = %s;\n", inColorName.c_str(), inColor.c_str());

- inColor = inColorName;

- }

- // create var to hold stage result

- SkString outColorName;

- this->nameVariable(&outColorName, '\0', "output");

- this->fsCodeAppendf("\tvec4 %s;\n", outColorName.c_str());

- outColor = outColorName;

- programEffectsBuilder->emitEffect(stage,

- keyProvider.get(e),

- outColor.c_str(),

- inColor.isOnes() ? NULL : inColor.c_str(),

- fCodeStage.stageIndex());

- inColor = outColor;

- effectEmitted = true;

- }

- if (effectEmitted) {

- *fsInOutColor = outColor;

- }

-const char* GrGLShaderBuilder::getColorOutputName() const {

- return fHasCustomColorOutput ? declared_color_output_name() : "gl_FragColor";

-const char* GrGLShaderBuilder::enableSecondaryOutput() {

- if (!fHasSecondaryOutput) {

- fFSOutputs.push_back().set(kVec4f_GrSLType,

- GrGLShaderVar::kOut_TypeModifier,

- dual_source_output_name());

- fHasSecondaryOutput = true;

- }

- return dual_source_output_name();

-bool GrGLShaderBuilder::finish() {

- SkASSERT(0 == fProgramID);

- GL_CALL_RET(fProgramID, CreateProgram());

- if (!fProgramID) {

- return false;

- }

- SkTDArray<GrGLuint> shadersToDelete;

- if (!this->compileAndAttachShaders(fProgramID, &shadersToDelete)) {

- GL_CALL(DeleteProgram(fProgramID));

- return false;

- }

- this->bindProgramLocations(fProgramID);

- GL_CALL(LinkProgram(fProgramID));

- // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.

- bool checkLinked = !fGpu->ctxInfo().isChromium();

-#ifdef SK_DEBUG

- checkLinked = true;

-#endif

- if (checkLinked) {

- GrGLint linked = GR_GL_INIT_ZERO;

- GL_CALL(GetProgramiv(fProgramID, GR_GL_LINK_STATUS, &linked));

- if (!linked) {

- GrGLint infoLen = GR_GL_INIT_ZERO;

- GL_CALL(GetProgramiv(fProgramID, 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(fProgramID,

- infoLen+1,

- &length,

- (char*)log.get()));

- GrPrintf((char*)log.get());

- }

- SkDEBUGFAIL("Error linking program");

- GL_CALL(DeleteProgram(fProgramID));

- fProgramID = 0;

- return false;

- }

- this->resolveProgramLocations(fProgramID);

- for (int i = 0; i < shadersToDelete.count(); ++i) {

- GL_CALL(DeleteShader(shadersToDelete[i]));

- }

- return true;

-// Compiles a GL shader and attaches it to a program. Returns the shader ID if

-// successful, or 0 if not.

-static GrGLuint attach_shader(const GrGLContext& glCtx,

- GrGLuint programId,

- GrGLenum type,

- const SkString& shaderSrc) {

- const GrGLInterface* gli = glCtx.interface();

- GrGLuint shaderId;

- GR_GL_CALL_RET(gli, shaderId, CreateShader(type));

- if (0 == shaderId) {

- return 0;

- }

-#ifdef SK_DEBUG

- SkString prettySource = GrGLSLPrettyPrint::PrettyPrintGLSL(shaderSrc, false);

- const GrGLchar* sourceStr = prettySource.c_str();

- GrGLint sourceLength = static_cast<GrGLint>(prettySource.size());

-#else

- GrGLint sourceLength = static_cast<GrGLint>(shaderSrc.size());

- const GrGLchar* sourceStr = shaderSrc.c_str();

-#endif

- GR_GL_CALL(gli, ShaderSource(shaderId, 1, &sourceStr, &sourceLength));

- GR_GL_CALL(gli, CompileShader(shaderId));

- // Calling GetShaderiv in Chromium is quite expensive. Assume success in release builds.

- bool checkCompiled = !glCtx.isChromium();

-#ifdef SK_DEBUG

- checkCompiled = true;

-#endif

- if (checkCompiled) {

- GrGLint compiled = GR_GL_INIT_ZERO;

- GR_GL_CALL(gli, GetShaderiv(shaderId, GR_GL_COMPILE_STATUS, &compiled));

- if (!compiled) {

- GrGLint infoLen = GR_GL_INIT_ZERO;

- GR_GL_CALL(gli, GetShaderiv(shaderId, 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 Chromium cmd

- // buffer param validation.

- GrGLsizei length = GR_GL_INIT_ZERO;

- GR_GL_CALL(gli, GetShaderInfoLog(shaderId, infoLen+1,

- &length, (char*)log.get()));

- GrPrintf(GrGLSLPrettyPrint::PrettyPrintGLSL(shaderSrc, true).c_str());

- GrPrintf("\n%s", log.get());

- }

- SkDEBUGFAIL("Shader compilation failed!");

- GR_GL_CALL(gli, DeleteShader(shaderId));

- return 0;

- }

- TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "skia_gpu::GLShader",

- TRACE_EVENT_SCOPE_THREAD, "shader", TRACE_STR_COPY(shaderSrc.c_str()));

- if (c_PrintShaders) {

- GrPrintf(GrGLSLPrettyPrint::PrettyPrintGLSL(shaderSrc, true).c_str());

- GrPrintf("\n");

- }

- // Attach the shader, but defer deletion until after we have linked the program.

- // This works around a bug in the Android emulator's GLES2 wrapper which

- // will immediately delete the shader object and free its memory even though it's

- // attached to a program, which then causes glLinkProgram to fail.

- GR_GL_CALL(gli, AttachShader(programId, shaderId));

- return shaderId;

-bool GrGLShaderBuilder::compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const {

- SkString fragShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));

- fragShaderSrc.append(fFSExtensions);

- append_default_precision_qualifier(kDefaultFragmentPrecision,

- fGpu->glStandard(),

- &fragShaderSrc);

- this->appendUniformDecls(kFragment_Visibility, &fragShaderSrc);

- this->appendDecls(fFSInputs, &fragShaderSrc);

- // We shouldn't have declared outputs on 1.10

- SkASSERT(k110_GrGLSLGeneration != fGpu->glslGeneration() || fFSOutputs.empty());

- this->appendDecls(fFSOutputs, &fragShaderSrc);

- fragShaderSrc.append(fFSFunctions);

- fragShaderSrc.append("void main() {\n");

- fragShaderSrc.append(fFSCode);

- fragShaderSrc.append("}\n");

- GrGLuint fragShaderId = attach_shader(fGpu->glContext(), programId, GR_GL_FRAGMENT_SHADER, fragShaderSrc);

- if (!fragShaderId) {

- return false;

- }

- *shaderIds->append() = fragShaderId;

- return true;

-void GrGLShaderBuilder::bindProgramLocations(GrGLuint programId) {

- if (fHasCustomColorOutput) {

- GL_CALL(BindFragDataLocation(programId, 0, declared_color_output_name()));

- }

- if (fHasSecondaryOutput) {

- GL_CALL(BindFragDataLocationIndexed(programId, 0, 1, dual_source_output_name()));

- }

- // skbug.com/2056

- bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;

- if (usingBindUniform) {

- 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;

- }

-void GrGLShaderBuilder::resolveProgramLocations(GrGLuint programId) {

- bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;

- if (!usingBindUniform) {

- 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;

- }

-const GrGLContextInfo& GrGLShaderBuilder::ctxInfo() const {

- return fGpu->ctxInfo();

-////////////////////////////////////////////////////////////////////////////////

-GrGLFullShaderBuilder::GrGLFullShaderBuilder(GrGpuGL* gpu,

- const GrGLProgramDesc& desc)

- : INHERITED(gpu, desc)

- , fVSAttrs(kVarsPerBlock)

- , fVSOutputs(kVarsPerBlock)

- , fGSInputs(kVarsPerBlock)

- , fGSOutputs(kVarsPerBlock) {

-void GrGLFullShaderBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) {

- const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();

- fHasVertexShader = true;

- fPositionVar = &fVSAttrs.push_back();

- fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, "aPosition");

- if (-1 != header.fLocalCoordAttributeIndex) {

- fLocalCoordsVar = &fVSAttrs.push_back();

- fLocalCoordsVar->set(kVec2f_GrSLType,

- GrGLShaderVar::kAttribute_TypeModifier,

- "aLocalCoords");

- } else {

- fLocalCoordsVar = fPositionVar;

- }

- const char* viewMName;

- fUniformHandles.fViewMatrixUni =

- this->addUniform(GrGLShaderBuilder::kVertex_Visibility, kMat33f_GrSLType, "ViewM",

- &viewMName);

- // Transform the position into Skia's device coords.

- this->vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n",

- viewMName, fPositionVar->c_str());

- // we output point size in the GS if present

- if (header.fEmitsPointSize

-#if GR_GL_EXPERIMENTAL_GS

- && !header.fExperimentalGS

-#endif

- ) {

- this->vsCodeAppend("\tgl_PointSize = 1.0;\n");

- }

- if (GrGLProgramDesc::kAttribute_ColorInput == header.fColorInput) {

- this->addAttribute(kVec4f_GrSLType, color_attribute_name());

- const char *vsName, *fsName;

- this->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);

- this->vsCodeAppendf("\t%s = %s;\n", vsName, color_attribute_name());

- *color = fsName;

- }

- if (GrGLProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {

- this->addAttribute(kVec4f_GrSLType, coverage_attribute_name());

- const char *vsName, *fsName;

- this->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);

- this->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());

- *coverage = fsName;

- }

-void GrGLFullShaderBuilder::emitCodeAfterEffects() {

- const char* rtAdjustName;

- fUniformHandles.fRTAdjustmentUni =

- this->addUniform(GrGLShaderBuilder::kVertex_Visibility, kVec4f_GrSLType, "rtAdjustment",

- &rtAdjustName);

- // Transform from Skia's device coords to GL's normalized device coords.

- this->vsCodeAppendf(

- "\tgl_Position = vec4(dot(pos3.xz, %s.xy), dot(pos3.yz, %s.zw), 0, pos3.z);\n",

- rtAdjustName, rtAdjustName);

-bool GrGLFullShaderBuilder::addAttribute(GrSLType type, const char* name) {

- for (int i = 0; i < fVSAttrs.count(); ++i) {

- const GrGLShaderVar& attr = fVSAttrs[i];

- // if attribute already added, don't add it again

- if (attr.getName().equals(name)) {

- SkASSERT(attr.getType() == type);

- return false;

- }

- fVSAttrs.push_back().set(type,

- GrGLShaderVar::kAttribute_TypeModifier,

- name);

- return true;

-bool GrGLFullShaderBuilder::addEffectAttribute(int attributeIndex,

- GrSLType type,

- const SkString& name) {

- if (!this->addAttribute(type, name.c_str())) {

- return false;

- }

- fEffectAttributes.push_back().set(attributeIndex, name);

- return true;

-void GrGLFullShaderBuilder::addVarying(GrSLType type,

- const char* name,

- const char** vsOutName,

- const char** fsInName) {

- fVSOutputs.push_back();

- fVSOutputs.back().setType(type);

- fVSOutputs.back().setTypeModifier(GrGLShaderVar::kVaryingOut_TypeModifier);

- this->nameVariable(fVSOutputs.back().accessName(), 'v', name);

- if (vsOutName) {

- *vsOutName = fVSOutputs.back().getName().c_str();

- }

- // input to FS comes either from VS or GS

- const SkString* fsName;

-#if GR_GL_EXPERIMENTAL_GS

- if (this->desc().getHeader().fExperimentalGS) {

- // if we have a GS take each varying in as an array

- // and output as non-array.

- fGSInputs.push_back();

- fGSInputs.back().setType(type);

- fGSInputs.back().setTypeModifier(GrGLShaderVar::kVaryingIn_TypeModifier);

- fGSInputs.back().setUnsizedArray();

- *fGSInputs.back().accessName() = fVSOutputs.back().getName();

- fGSOutputs.push_back();

- fGSOutputs.back().setType(type);

- fGSOutputs.back().setTypeModifier(GrGLShaderVar::kVaryingOut_TypeModifier);

- this->nameVariable(fGSOutputs.back().accessName(), 'g', name);

- fsName = fGSOutputs.back().accessName();

- } else

-#endif

- {

- fsName = fVSOutputs.back().accessName();

- }

- this->fsInputAppend().set(type, GrGLShaderVar::kVaryingIn_TypeModifier, *fsName);

- if (fsInName) {

- *fsInName = fsName->c_str();

- }

-const SkString* GrGLFullShaderBuilder::getEffectAttributeName(int attributeIndex) const {

- const AttributePair* attribEnd = fEffectAttributes.end();

- for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {

- if (attrib->fIndex == attributeIndex) {

- return &attrib->fName;

- }

- return NULL;

-GrGLProgramEffects* GrGLFullShaderBuilder::createAndEmitEffects(

- const GrEffectStage* effectStages[],

- int effectCnt,

- const GrGLProgramDesc::EffectKeyProvider& keyProvider,

- GrGLSLExpr4* inOutFSColor) {

- GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);

- this->INHERITED::createAndEmitEffects(&programEffectsBuilder,

- effectStages,

- effectCnt,

- keyProvider,

- inOutFSColor);

- return programEffectsBuilder.finish();

-bool GrGLFullShaderBuilder::compileAndAttachShaders(GrGLuint programId,

- SkTDArray<GrGLuint>* shaderIds) const {

- const GrGLContext& glCtx = this->gpu()->glContext();

- SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));

- this->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);

- this->appendDecls(fVSAttrs, &vertShaderSrc);

- this->appendDecls(fVSOutputs, &vertShaderSrc);

- vertShaderSrc.append("void main() {\n");

- vertShaderSrc.append(fVSCode);

- vertShaderSrc.append("}\n");

- GrGLuint vertShaderId = attach_shader(glCtx, programId, GR_GL_VERTEX_SHADER, vertShaderSrc);

- if (!vertShaderId) {

- return false;

- }

- *shaderIds->append() = vertShaderId;

-#if GR_GL_EXPERIMENTAL_GS

- if (this->desc().getHeader().fExperimentalGS) {

- SkASSERT(this->ctxInfo().glslGeneration() >= k150_GrGLSLGeneration);

- SkString geomShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));

- geomShaderSrc.append("layout(triangles) in;\n"

- "layout(triangle_strip, max_vertices = 6) out;\n");

- this->appendDecls(fGSInputs, &geomShaderSrc);

- this->appendDecls(fGSOutputs, &geomShaderSrc);

- geomShaderSrc.append("void main() {\n");

- geomShaderSrc.append("\tfor (int i = 0; i < 3; ++i) {\n"

- "\t\tgl_Position = gl_in[i].gl_Position;\n");

- if (this->desc().getHeader().fEmitsPointSize) {

- geomShaderSrc.append("\t\tgl_PointSize = 1.0;\n");

- }

- SkASSERT(fGSInputs.count() == fGSOutputs.count());

- for (int i = 0; i < fGSInputs.count(); ++i) {

- geomShaderSrc.appendf("\t\t%s = %s[i];\n",

- fGSOutputs[i].getName().c_str(),

- fGSInputs[i].getName().c_str());

- }

- geomShaderSrc.append("\t\tEmitVertex();\n"

- "\t}\n"

- "\tEndPrimitive();\n");

- geomShaderSrc.append("}\n");

- GrGLuint geomShaderId = attach_shader(glCtx, programId, GR_GL_GEOMETRY_SHADER, geomShaderSrc);

- if (!geomShaderId) {

- return false;

- }

- *shaderIds->append() = geomShaderId;

- }

-#endif

- return this->INHERITED::compileAndAttachShaders(programId, shaderIds);

-void GrGLFullShaderBuilder::bindProgramLocations(GrGLuint programId) {

- this->INHERITED::bindProgramLocations(programId);

- const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();

- // Bind the attrib locations to same values for all shaders

- SkASSERT(-1 != header.fPositionAttributeIndex);

- GL_CALL(BindAttribLocation(programId,

- header.fPositionAttributeIndex,

- fPositionVar->c_str()));

- if (-1 != header.fLocalCoordAttributeIndex) {

- GL_CALL(BindAttribLocation(programId,

- header.fLocalCoordAttributeIndex,

- fLocalCoordsVar->c_str()));

- }

- if (-1 != header.fColorAttributeIndex) {

- GL_CALL(BindAttribLocation(programId,

- header.fColorAttributeIndex,

- color_attribute_name()));

- }

- if (-1 != header.fCoverageAttributeIndex) {

- GL_CALL(BindAttribLocation(programId,

- header.fCoverageAttributeIndex,

- coverage_attribute_name()));

- }

- const AttributePair* attribEnd = fEffectAttributes.end();

- for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {

- GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));

- }

-////////////////////////////////////////////////////////////////////////////////

-GrGLFragmentOnlyShaderBuilder::GrGLFragmentOnlyShaderBuilder(GrGpuGL* gpu,

- const GrGLProgramDesc& desc)

- : INHERITED(gpu, desc) {

- SkASSERT(!desc.getHeader().fHasVertexCode);

- SkASSERT(gpu->glCaps().pathRenderingSupport());

- SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);

- SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);

-int GrGLFragmentOnlyShaderBuilder::addTexCoordSets(int count) {

- int firstFreeCoordSet = fTexCoordSetCnt;

- fTexCoordSetCnt += count;

- SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fTexCoordSetCnt);

- return firstFreeCoordSet;

-GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(

- const GrEffectStage* effectStages[],

- int effectCnt,

- const GrGLProgramDesc::EffectKeyProvider& keyProvider,

- GrGLSLExpr4* inOutFSColor) {

- GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,

- effectCnt);

- this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,

- effectStages,

- effectCnt,

- keyProvider,

- inOutFSColor);

- return pathTexGenEffectsBuilder.finish();

« gyp/gpu.gypi ('K') | « src/gpu/gl/GrGLShaderBuilder.h ('k') | src/gpu/gl/GrGLVertexEffect.h » ('j') | src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp » ('J')