const char *rectName;
const char *profileSizeName;
- const char* precisionString = GrGLSLShaderVar::PrecisionString(args.fBuilder->glslCaps(),
- fPrecision);
+ const char* precisionString = GrGLSLShaderVar::PrecisionString(args.fGLSLCaps, fPrecision);
fProxyRectUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
kVec4f_GrSLType,
fPrecision,
}
fragBuilder->codeAppend("-vec2(0.5));\t\t");
- fGLDomain.sampleTexture(fragBuilder, domain, args.fOutputColor, SkString(cCoords),
+ fGLDomain.sampleTexture(fragBuilder,
+ args.fGLSLCaps,
+ domain,
+ args.fOutputColor,
+ SkString(cCoords),
args.fSamplers[1]);
fragBuilder->codeAppend(";\n");
}
void GrGLGradientEffect::emitColor(GrGLSLFPBuilder* builder,
GrGLSLFragmentBuilder* fragBuilder,
+ const GrGLSLCaps* glslCaps,
const GrGradientEffect& ge,
const char* gradientTValue,
const char* outputColor,
// considerations:
// The gradient SkShader reporting opaque is more restrictive than necessary in the two pt
// case. Make sure the key reflects this optimization (and note that it can use the same
- // shader as thekBeforeIterp case). This same optimization applies to the 3 color case below.
+ // shader as thekBeforeIterp case). This same optimization applies to the 3 color case
+ // below.
if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
fragBuilder->codeAppend("\tcolorTemp.rgb *= colorTemp.a;\n");
}
gradientTValue);
fragBuilder->codeAppendf("\tvec4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s;\n",
builder->getUniformVariable(fColorStartUni).c_str());
- if (!builder->glslCaps()->canUseMinAndAbsTogether()) {
+ if (!glslCaps->canUseMinAndAbsTogether()) {
// The Tegra3 compiler will sometimes never return if we have
// min(abs(oneMinus2t), 1.0), or do the abs first in a separate expression.
fragBuilder->codeAppend("\tfloat minAbs = abs(oneMinus2t);\n");
// native GLSL mix), and 4+ color gradients that use the traditional texture lookup.
void emitColor(GrGLSLFPBuilder* builder,
GrGLSLFragmentBuilder* fragBuilder,
+ const GrGLSLCaps* caps,
const GrGradientEffect&,
const char* gradientTValue,
const char* outputColor,
t.append(".x");
this->emitColor(args.fBuilder,
args.fFragBuilder,
+ args.fGLSLCaps,
ge, t.c_str(),
args.fOutputColor,
args.fInputColor,
t.append(")");
this->emitColor(args.fBuilder,
args.fFragBuilder,
+ args.fGLSLCaps,
ge, t.c_str(),
args.fOutputColor,
args.fInputColor,
// 0.1591549430918 is 1/(2*pi), used since atan returns values [-pi, pi]
// On Intel GPU there is an issue where it reads the second arguement to atan "- %s.x" as an int
// thus must us -1.0 * %s.x to work correctly
- if (args.fBuilder->glslCaps()->mustForceNegatedAtanParamToFloat()){
+ if (args.fGLSLCaps->mustForceNegatedAtanParamToFloat()){
t.printf("atan(- %s.y, -1.0 * %s.x) * 0.1591549430918 + 0.5",
coords2D.c_str(), coords2D.c_str());
} else {
}
this->emitColor(args.fBuilder,
args.fFragBuilder,
+ args.fGLSLCaps,
ge, t.c_str(),
args.fOutputColor,
args.fInputColor,
fragBuilder->codeAppend("\t");
this->emitColor(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
ge,
tName.c_str(),
args.fOutputColor,
fragBuilder->codeAppend("\t\t");
this->emitColor(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
ge,
tName.c_str(),
args.fOutputColor,
this->emitColor(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
ge,
tName.c_str(),
args.fOutputColor,
this->emitColor(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
ge,
tName.c_str(),
args.fOutputColor,
fragBuilder->codeAppend("\t\t");
this->emitColor(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
ge,
tName.c_str(),
args.fOutputColor,
coord.printf("coord + %s * vec2(%d, %d)", imgInc, x - 1, y - 1);
SkString sampleVar;
sampleVar.printf("rowColors[%d]", x);
- fDomain.sampleTexture(fragBuilder, domain, sampleVar.c_str(), coord, args.fSamplers[0]);
+ fDomain.sampleTexture(fragBuilder,
+ args.fGLSLCaps,
+ domain,
+ sampleVar.c_str(),
+ coord,
+ args.fSamplers[0]);
}
fragBuilder->codeAppendf(
"\tvec4 s%d = %s(%s, f.x, rowColors[0], rowColors[1], rowColors[2], rowColors[3]);\n",
// Using highp for GLES here in order to avoid some precision issues on specific GPUs.
GrGLSLShaderVar tmpVar("tmpColor", kVec4f_GrSLType, 0, kHigh_GrSLPrecision);
SkString tmpDecl;
- tmpVar.appendDecl(args.fBuilder->glslCaps(), &tmpDecl);
+ tmpVar.appendDecl(args.fGLSLCaps, &tmpDecl);
GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
dfTexEffect.inTextureCoords()->fName);
// Use highp to work around aliasing issues
- fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(pb->glslCaps(),
+ fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(args.fGLSLCaps,
kHigh_GrSLPrecision));
fragBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
"TextureSize", &textureSizeUniName);
// Use highp to work around aliasing issues
- fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(pb->glslCaps(),
+ fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(args.fGLSLCaps,
kHigh_GrSLPrecision));
fragBuilder->codeAppendf("vec2 uv = %s;", v.fsIn());
fragBuilder->codeAppend("float distance = "
SK_DistanceFieldMultiplier "*(texColor - " SK_DistanceFieldThreshold ");");
- fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(pb->glslCaps(),
+ fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(args.fGLSLCaps,
kHigh_GrSLPrecision));
fragBuilder->codeAppendf("vec2 st = uv*%s;", textureSizeUniName);
fragBuilder->codeAppend("float afwidth;");
// create LCD offset adjusted by inverse of transform
// Use highp to work around aliasing issues
- fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(pb->glslCaps(),
+ fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(args.fGLSLCaps,
kHigh_GrSLPrecision));
fragBuilder->codeAppendf("vec2 uv = %s;\n", uv.fsIn());
- fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(pb->glslCaps(),
+ fragBuilder->codeAppend(GrGLSLShaderVar::PrecisionString(args.fGLSLCaps,
kHigh_GrSLPrecision));
SkScalar lcdDelta = 1.0f / (3.0f * atlas->width());
fragBuilder->codeAppendf("float k = %s[%d * %d + %d];", kernel, y, kWidth, x);
SkString coord;
coord.printf("coord + vec2(%d, %d) * %s", x, y, imgInc);
- fDomain.sampleTexture(fragBuilder, domain, "c", coord, args.fSamplers[0]);
+ fDomain.sampleTexture(fragBuilder,
+ args.fGLSLCaps,
+ domain,
+ "c",
+ coord,
+ args.fSamplers[0]);
if (!fConvolveAlpha) {
fragBuilder->codeAppend("c.rgb /= c.a;");
fragBuilder->codeAppend("c.rgb = clamp(c.rgb, 0.0, 1.0);");
fragBuilder->codeAppendf("%s.rgb = clamp(%s.rgb, 0.0, %s.a);",
args.fOutputColor, args.fOutputColor, args.fOutputColor);
} else {
- fDomain.sampleTexture(fragBuilder, domain, "c", coords2D, args.fSamplers[0]);
+ fDomain.sampleTexture(fragBuilder,
+ args.fGLSLCaps,
+ domain,
+ "c",
+ coords2D,
+ args.fSamplers[0]);
fragBuilder->codeAppendf("%s.a = c.a;", args.fOutputColor);
fragBuilder->codeAppendf("%s.rgb = sum.rgb * %s + %s;", args.fOutputColor, gain, bias);
fragBuilder->codeAppendf("%s.rgb *= %s.a;", args.fOutputColor, args.fOutputColor);
//////////////////////////////////////////////////////////////////////////////
void GrTextureDomain::GLDomain::sampleTexture(GrGLSLShaderBuilder* builder,
+ const GrGLSLCaps* glslCaps,
const GrTextureDomain& textureDomain,
const char* outColor,
const SkString& inCoords,
GrGLSLShaderBuilder::ShaderBlock block(builder);
const char* domain = fDomainName.c_str();
- if (!program->glslCaps()->canUseAnyFunctionInShader()) {
+ if (!glslCaps->canUseAnyFunctionInShader()) {
// On the NexusS and GalaxyNexus, the other path (with the 'any'
// call) causes the compilation error "Calls to any function that
// may require a gradient calculation inside a conditional block
inCoords.c_str());
builder->codeAppend(";");
- builder->codeAppend(GrGLSLShaderVar::PrecisionString(program->glslCaps(),
+ builder->codeAppend(GrGLSLShaderVar::PrecisionString(glslCaps,
kHigh_GrSLPrecision));
builder->codeAppendf("float x = (%s).x;", inCoords.c_str());
- builder->codeAppend(GrGLSLShaderVar::PrecisionString(program->glslCaps(),
+ builder->codeAppend(GrGLSLShaderVar::PrecisionString(glslCaps,
kHigh_GrSLPrecision));
builder->codeAppendf("float y = (%s).y;", inCoords.c_str());
GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
SkString coords2D = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
- fGLDomain.sampleTexture(fragBuilder, domain, args.fOutputColor, coords2D, args.fSamplers[0],
+ fGLDomain.sampleTexture(fragBuilder,
+ args.fGLSLCaps,
+ domain,
+ args.fOutputColor,
+ coords2D,
+ args.fSamplers[0],
args.fInputColor);
}
* expression before being written to outColor.
*/
void sampleTexture(GrGLSLShaderBuilder* builder,
+ const GrGLSLCaps* glslCaps,
const GrTextureDomain& textureDomain,
const char* outColor,
const SkString& inCoords,
GrGLSLFragmentProcessor::EmitArgs args(this,
&fFS,
+ this->glslCaps(),
fp,
outColor,
inColor,
SkSTArray<4, GrGLSLTextureSampler> samplers(gp.numTextures());
this->emitSamplers(gp, &samplers, fGeometryProcessor);
- GrGLSLGeometryProcessor::EmitArgs args(this, &fVS, &fFS, gp, outColor, outCoverage, samplers,
- fCoordTransforms, &fOutCoords);
+ GrGLSLGeometryProcessor::EmitArgs args(this,
+ &fVS,
+ &fFS,
+ this->glslCaps(),
+ gp,
+ outColor,
+ outCoverage,
+ samplers,
+ fCoordTransforms,
+ &fOutCoords);
fGeometryProcessor->fGLProc->emitCode(args);
// We have to check that effects and the code they emit are consistent, ie if an effect
SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
this->emitSamplers(xp, &samplers, fXferProcessor);
- GrGLSLXferProcessor::EmitArgs args(this, &fFS, xp, colorIn.c_str(), coverageIn.c_str(),
+ GrGLSLXferProcessor::EmitArgs args(this,
+ &fFS,
+ this->glslCaps(),
+ xp, colorIn.c_str(),
+ coverageIn.c_str(),
fFS.getPrimaryColorOutputName(),
- fFS.getSecondaryColorOutputName(), samplers);
+ fFS.getSecondaryColorOutputName(),
+ samplers);
fXferProcessor->fGLProc->emitCode(args);
// We have to check that effects and the code they emit are consistent, ie if an effect
fragBuilder->getMangleString().c_str(), childProc.name());
EmitArgs childArgs(args.fBuilder,
fragBuilder,
+ args.fGLSLCaps,
childProc,
outputColor,
inputColor,
struct EmitArgs {
EmitArgs(GrGLSLFPBuilder* builder,
GrGLSLFragmentBuilder* fragBuilder,
+ const GrGLSLCaps* caps,
const GrFragmentProcessor& fp,
const char* outputColor,
const char* inputColor,
const TextureSamplerArray& samplers)
: fBuilder(builder)
, fFragBuilder(fragBuilder)
+ , fGLSLCaps(caps)
, fFp(fp)
, fOutputColor(outputColor)
, fInputColor(inputColor)
, fSamplers(samplers) {}
GrGLSLFPBuilder* fBuilder;
GrGLSLFragmentBuilder* fFragBuilder;
+ const GrGLSLCaps* fGLSLCaps;
const GrFragmentProcessor& fFp;
const char* fOutputColor;
const char* fInputColor;
class GrBatchTracker;
class GrPrimitiveProcessor;
-class GrGLSLVertexBuilder;
+class GrGLSLCaps;
class GrGLSLFragmentBuilder;
class GrGLSLGPBuilder;
+class GrGLSLVertexBuilder;
class GrGLSLPrimitiveProcessor {
public:
EmitArgs(GrGLSLGPBuilder* pb,
GrGLSLVertexBuilder* vertBuilder,
GrGLSLFragmentBuilder* fragBuilder,
+ const GrGLSLCaps* caps,
const GrPrimitiveProcessor& gp,
const char* outputColor,
const char* outputCoverage,
: fPB(pb)
, fVertBuilder(vertBuilder)
, fFragBuilder(fragBuilder)
+ , fGLSLCaps(caps)
, fGP(gp)
, fOutputColor(outputColor)
, fOutputCoverage(outputCoverage)
GrGLSLGPBuilder* fPB;
GrGLSLVertexBuilder* fVertBuilder;
GrGLSLFragmentBuilder* fFragBuilder;
+ const GrGLSLCaps* fGLSLCaps;
const GrPrimitiveProcessor& fGP;
const char* fOutputColor;
const char* fOutputCoverage;
*/
virtual const char* getUniformCStr(UniformHandle u) const = 0;
- virtual const GrGLSLCaps* glslCaps() const = 0;
-
/*
* *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
*/
public:
typedef GrGpu::DrawArgs DrawArgs;
+ virtual const GrGLSLCaps* glslCaps() const = 0;
+
// Handles for program uniforms (other than per-effect uniforms)
struct BuiltinUniformHandles {
UniformHandle fRTAdjustmentUni;
#include "glsl/GrGLSLProgramDataManager.h"
#include "glsl/GrGLSLTextureSampler.h"
-class GrGLSLXPFragmentBuilder;
-class GrGLSLXPBuilder;
class GrXferProcessor;
+class GrGLSLXPBuilder;
+class GrGLSLXPFragmentBuilder;
+class GrGLSLCaps;
class GrGLSLXferProcessor {
public:
struct EmitArgs {
EmitArgs(GrGLSLXPBuilder* pb,
GrGLSLXPFragmentBuilder* fragBuilder,
+ const GrGLSLCaps* caps,
const GrXferProcessor& xp,
const char* inputColor,
const char* inputCoverage,
const TextureSamplerArray& samplers)
: fPB(pb)
, fXPFragBuilder(fragBuilder)
+ , fGLSLCaps(caps)
, fXP(xp)
, fInputColor(inputColor)
, fInputCoverage(inputCoverage)
GrGLSLXPBuilder* fPB;
GrGLSLXPFragmentBuilder* fXPFragBuilder;
+ const GrGLSLCaps* fGLSLCaps;
const GrXferProcessor& fXP;
const char* fInputColor;
const char* fInputCoverage;