Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(57)

Issues Search
    My Issues | Starred     Open | Closed | All

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: 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
Download patch
« no previous file with comments | « src/gpu/gl/GrGLShaderBuilder.h ('k') | src/gpu/gl/GrGLVertexEffect.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 @@
-/*
- * Copyright 2012 Google Inc.
- *
- * 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();
-}
« no previous file with comments | « src/gpu/gl/GrGLShaderBuilder.h ('k') | src/gpu/gl/GrGLVertexEffect.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698