GrShaderCaps always stores config texture swizzles.
Previously the swizzles were all "rgba" when GL texture swizzle was
used. This made it impossible to know the component mapping in that
case from API-neutral code.
Change-Id: I5e55fec87f0de2f8d43d8dc7759125482fccd91c
Bug: skia:8962
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/218280
Commit-Queue: Brian Salomon <bsalomon@google.com>
Auto-Submit: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/src/gpu/GrProgramDesc.cpp b/src/gpu/GrProgramDesc.cpp
index 344a2a5..05f8505 100644
--- a/src/gpu/GrProgramDesc.cpp
+++ b/src/gpu/GrProgramDesc.cpp
@@ -44,8 +44,12 @@
int samplerTypeKey = texture_type_key(textureType);
GR_STATIC_ASSERT(2 == sizeof(caps.configTextureSwizzle(config).asKey()));
+ uint16_t swizzleKey = 0;
+ if (caps.textureSwizzleAppliedInShader()) {
+ swizzleKey = caps.configTextureSwizzle(config).asKey();
+ }
return SkToU32(samplerTypeKey |
- caps.configTextureSwizzle(config).asKey() << kSamplerOrImageTypeKeyBits |
+ swizzleKey << kSamplerOrImageTypeKeyBits |
(GrSLSamplerPrecision(config) << (16 + kSamplerOrImageTypeKeyBits)));
}
diff --git a/src/gpu/GrShaderCaps.cpp b/src/gpu/GrShaderCaps.cpp
index 24c7b49..7ca3e33 100644
--- a/src/gpu/GrShaderCaps.cpp
+++ b/src/gpu/GrShaderCaps.cpp
@@ -55,6 +55,9 @@
fHalfIs32Bits = false;
fHasLowFragmentPrecision = false;
fUnsignedSupport = false;
+ // Backed API support is required to be able to make swizzle-neutral shaders (e.g.
+ // GL_ARB_texture_swizzle).
+ fTextureSwizzleAppliedInShader = true;
fBuiltinFMASupport = false;
fVersionDeclString = nullptr;
@@ -130,6 +133,8 @@
writer->appendBool("float == fp32", fFloatIs32Bits);
writer->appendBool("half == fp32", fHalfIs32Bits);
writer->appendBool("Has poor fragment precision", fHasLowFragmentPrecision);
+ writer->appendBool("Unsigned support", fUnsignedSupport);
+ writer->appendBool("Texture swizzle applied in shader", fTextureSwizzleAppliedInShader);
writer->appendBool("Builtin fma() support", fBuiltinFMASupport);
writer->appendS32("Max FS Samplers", fMaxFragmentSamplers);
diff --git a/src/gpu/GrShaderCaps.h b/src/gpu/GrShaderCaps.h
index 18ba8a5..ad0e994 100644
--- a/src/gpu/GrShaderCaps.h
+++ b/src/gpu/GrShaderCaps.h
@@ -239,6 +239,8 @@
return fConfigTextureSwizzle[config];
}
+ bool textureSwizzleAppliedInShader() const { return fTextureSwizzleAppliedInShader; }
+
/** Swizzle that should occur on the fragment shader outputs for a given config. */
const GrSwizzle& configOutputSwizzle(GrPixelConfig config) const {
return fConfigOutputSwizzle[config];
@@ -274,6 +276,7 @@
bool fHalfIs32Bits : 1;
bool fHasLowFragmentPrecision : 1;
bool fUnsignedSupport : 1;
+ bool fTextureSwizzleAppliedInShader : 1;
// Used by SkSL to know when to generate polyfills.
bool fBuiltinFMASupport : 1;
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 4d97207..ae59460 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -45,7 +45,6 @@
fIsCoreProfile = false;
fBindFragDataLocationSupport = false;
fRectangleTextureSupport = false;
- fTextureSwizzleSupport = false;
fRGBA8888PixelsOpsAreSlow = false;
fPartialFBOReadIsSlow = false;
fMipMapLevelAndLodControlSupport = false;
@@ -267,11 +266,11 @@
if (GR_IS_GR_GL(standard)) {
if (version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle")) {
- fTextureSwizzleSupport = true;
+ this->fShaderCaps->fTextureSwizzleAppliedInShader = false;
}
} else if (GR_IS_GR_GL_ES(standard)) {
if (version >= GR_GL_VER(3,0)) {
- fTextureSwizzleSupport = true;
+ this->fShaderCaps->fTextureSwizzleAppliedInShader = false;
}
} // no WebGL support
@@ -1247,7 +1246,6 @@
writer->appendBool("Partial FBO read is slow", fPartialFBOReadIsSlow);
writer->appendBool("Bind uniform location support", fBindUniformLocationSupport);
writer->appendBool("Rectangle texture support", fRectangleTextureSupport);
- writer->appendBool("Texture swizzle support", fTextureSwizzleSupport);
writer->appendBool("BGRA to RGBA readback conversions are slow",
fRGBAToBGRAReadbackConversionsAreSlow);
writer->appendBool("Use buffer data null hint", fUseBufferDataNullHint);
@@ -1539,7 +1537,7 @@
fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = 0;
fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalType = 0;
fConfigTable[kUnknown_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
- fConfigTable[kUnknown_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kUnknown_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
@@ -1564,7 +1562,7 @@
if (texStorageSupported) {
fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGBA_8888_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kRGB_888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGB;
fConfigTable[kRGB_888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB8;
@@ -1598,13 +1596,13 @@
if (texStorageSupported) {
fConfigTable[kRGB_888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGB_888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGB_888_GrPixelConfig] = GrSwizzle::RGBA();
if (disableRGB8ForMali400) {
fConfigTable[kRGB_888_GrPixelConfig].fFlags = 0;
}
fConfigTable[kRGB_888X_GrPixelConfig] = fConfigTable[kRGBA_8888_GrPixelConfig];
- fConfigTable[kRGB_888X_GrPixelConfig].fSwizzle = GrSwizzle::RGB1();
+ shaderCaps->fConfigTextureSwizzle[kRGB_888X_GrPixelConfig] = GrSwizzle::RGB1();
// Currently we don't allow RGB_888X to be renderable because we don't have a way to handle
// blends that reference the dst alpha when the values in the dst alpha channel are
// uninitialized.
@@ -1625,7 +1623,7 @@
} else {
fConfigTable[kRG_88_GrPixelConfig].fFlags = 0;
}
- fConfigTable[kRG_88_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRG_88_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] =
GR_GL_BGRA;
@@ -1689,7 +1687,7 @@
if (texStorageSupported && supportsBGRATexStorage) {
fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kBGRA_8888_GrPixelConfig] = GrSwizzle::RGBA();
// We only enable srgb support if both textures and FBOs support srgb.
if (GR_IS_GR_GL(standard)) {
@@ -1755,7 +1753,7 @@
if (texStorageSupported && !disablePerFormatTextureStorageForCommandBufferES2) {
fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kSRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kSRGBA_8888_GrPixelConfig] = GrSwizzle::RGBA();
// sBGRA is not a "real" thing in OpenGL, but GPUs support it, and on platforms where
// kN32 == BGRA, we need some way to work with it. (The default framebuffer on Windows
// is in this format, for example).
@@ -1775,7 +1773,7 @@
if (texStorageSupported) {
fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kSBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kSBGRA_8888_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kRGB_565_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGB;
if (this->ES2CompatibilitySupport()) {
@@ -1807,7 +1805,7 @@
if (texStorageSupported && GR_IS_GR_GL_ES(standard)) {
fConfigTable[kRGB_565_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGB_565_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGB_565_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA4;
@@ -1828,7 +1826,7 @@
if (texStorageSupported) {
fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGBA_4444_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGBA_4444_GrPixelConfig] = GrSwizzle::RGBA();
fConfigTable[kRGBA_1010102_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_1010102_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB10_A2;
@@ -1849,7 +1847,7 @@
if (texStorageSupported) {
fConfigTable[kRGBA_1010102_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGBA_1010102_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGBA_1010102_GrPixelConfig] = GrSwizzle::RGBA();
bool alpha8IsValidForGL = GR_IS_GR_GL(standard) &&
(!fIsCoreProfile || version <= GR_GL_VER(3, 0));
@@ -1865,7 +1863,7 @@
alphaInfo.fFormats.fBaseInternalFormat = GR_GL_ALPHA;
alphaInfo.fFormats.fSizedInternalFormat = GR_GL_ALPHA8;
alphaInfo.fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = GR_GL_ALPHA;
- alphaInfo.fSwizzle = GrSwizzle::AAAA();
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_as_Alpha_GrPixelConfig] = GrSwizzle::AAAA();
if (fAlpha8IsRenderable && alpha8IsValidForGL) {
alphaInfo.fFlags |= allRenderFlags;
}
@@ -1876,7 +1874,7 @@
redInfo.fFormats.fBaseInternalFormat = GR_GL_RED;
redInfo.fFormats.fSizedInternalFormat = GR_GL_R8;
redInfo.fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = GR_GL_RED;
- redInfo.fSwizzle = GrSwizzle::RRRR();
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_as_Red_GrPixelConfig] = GrSwizzle::RRRR();
// ES2 Command Buffer does not allow TexStorage with R8_EXT (so Alpha_8 and Gray_8)
if (texStorageSupported && !disablePerFormatTextureStorageForCommandBufferES2) {
@@ -1889,10 +1887,14 @@
if (textureRedSupport) {
redInfo.fFlags |= ConfigInfo::kTextureable_Flag | allRenderFlags;
fConfigTable[kAlpha_8_GrPixelConfig] = redInfo;
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_GrPixelConfig] =
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_as_Red_GrPixelConfig];
} else {
redInfo.fFlags = 0;
fConfigTable[kAlpha_8_GrPixelConfig] = alphaInfo;
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_GrPixelConfig] =
+ shaderCaps->fConfigTextureSwizzle[kAlpha_8_as_Alpha_GrPixelConfig];
}
ConfigInfo& grayLumInfo = fConfigTable[kGray_8_as_Lum_GrPixelConfig];
@@ -1901,7 +1903,8 @@
grayLumInfo.fFormats.fBaseInternalFormat = GR_GL_LUMINANCE;
grayLumInfo.fFormats.fSizedInternalFormat = GR_GL_LUMINANCE8;
grayLumInfo.fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = GR_GL_LUMINANCE;
- grayLumInfo.fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kGray_8_as_Lum_GrPixelConfig] = GrSwizzle::RGBA();
+
if ((GR_IS_GR_GL(standard) && version <= GR_GL_VER(3, 0)) ||
(GR_IS_GR_GL_ES(standard) && version < GR_GL_VER(3, 0)) ||
(GR_IS_GR_WEBGL(standard))) {
@@ -1914,7 +1917,7 @@
grayRedInfo.fFormats.fBaseInternalFormat = GR_GL_RED;
grayRedInfo.fFormats.fSizedInternalFormat = GR_GL_R8;
grayRedInfo.fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = GR_GL_RED;
- grayRedInfo.fSwizzle = GrSwizzle::RRRA();
+ shaderCaps->fConfigTextureSwizzle[kGray_8_as_Red_GrPixelConfig] = GrSwizzle::RRRA();
grayRedInfo.fFlags = ConfigInfo::kTextureable_Flag;
// Leaving Gray8 as non-renderable, to keep things simple and match raster. However, we do
@@ -1936,9 +1939,13 @@
if (textureRedSupport) {
fConfigTable[kGray_8_GrPixelConfig] = grayRedInfo;
+ shaderCaps->fConfigTextureSwizzle[kGray_8_GrPixelConfig] =
+ shaderCaps->fConfigTextureSwizzle[kGray_8_as_Red_GrPixelConfig];
} else {
grayRedInfo.fFlags = 0;
fConfigTable[kGray_8_GrPixelConfig] = grayLumInfo;
+ shaderCaps->fConfigTextureSwizzle[kGray_8_GrPixelConfig] =
+ shaderCaps->fConfigTextureSwizzle[kGray_8_as_Lum_GrPixelConfig];
}
// Check for [half] floating point texture support
@@ -2034,7 +2041,7 @@
if (texStorageSupported) {
fConfigTable[fpconfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[fpconfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[fpconfig] = GrSwizzle::RGBA();
}
GrGLenum redHalfExternalType;
@@ -2050,7 +2057,7 @@
redHalf.fFormats.fBaseInternalFormat = GR_GL_RED;
redHalf.fFormats.fSizedInternalFormat = GR_GL_R16F;
redHalf.fFormats.fExternalFormat[kReadPixels_ExternalFormatUsage] = GR_GL_RED;
- redHalf.fSwizzle = GrSwizzle::RRRR();
+ shaderCaps->fConfigTextureSwizzle[kAlpha_half_as_Red_GrPixelConfig] = GrSwizzle::RRRR();
if (textureRedSupport && hasFP16Textures) {
redHalf.fFlags = ConfigInfo::kTextureable_Flag;
@@ -2063,6 +2070,8 @@
}
}
fConfigTable[kAlpha_half_GrPixelConfig] = redHalf;
+ shaderCaps->fConfigTextureSwizzle[kAlpha_half_GrPixelConfig] =
+ shaderCaps->fConfigTextureSwizzle[kAlpha_half_as_Red_GrPixelConfig];
fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA16F;
@@ -2085,7 +2094,7 @@
if (texStorageSupported && !disablePerFormatTextureStorageForCommandBufferES2) {
fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
}
- fConfigTable[kRGBA_half_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGBA_half_GrPixelConfig] = GrSwizzle::RGBA();
// kRGBA_half_Clamped is just distinguished by clamps added to the shader. At the API level,
// it's identical to kRGBA_half.
@@ -2124,7 +2133,7 @@
fConfigTable[kRGB_ETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
}
} // No WebGL support
- fConfigTable[kRGB_ETC1_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
+ shaderCaps->fConfigTextureSwizzle[kRGB_ETC1_GrPixelConfig] = GrSwizzle::RGBA();
// Bulk populate the texture internal/external formats here and then deal with exceptions below.
@@ -2201,14 +2210,6 @@
}
}
- // If we don't have texture swizzle support then the shader generator must insert the
- // swizzle into shader code.
- if (!this->textureSwizzleSupport()) {
- for (int i = 0; i < kGrPixelConfigCnt; ++i) {
- shaderCaps->fConfigTextureSwizzle[i] = fConfigTable[i].fSwizzle;
- }
- }
-
// Shader output swizzles will default to RGBA. When we've use GL_RED instead of GL_ALPHA to
// implement kAlpha_8_GrPixelConfig we need to swizzle the shader outputs so the alpha channel
// gets written to the single component.
diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h
index edb76df..a2e2948 100644
--- a/src/gpu/gl/GrGLCaps.h
+++ b/src/gpu/gl/GrGLCaps.h
@@ -133,11 +133,6 @@
return SkToBool(fConfigTable[config].fFlags & ConfigInfo::kCanUseTexStorage_Flag);
}
- /** Returns the mapping between GrPixelConfig components and GL internal format components. */
- const GrSwizzle& configSwizzle(GrPixelConfig config) const {
- return fConfigTable[config].fSwizzle;
- }
-
GrGLenum configSizedInternalFormat(GrPixelConfig config) const {
return fConfigTable[config].fFormats.fSizedInternalFormat;
}
@@ -330,9 +325,6 @@
/// Are textures with GL_TEXTURE_RECTANGLE type supported.
bool rectangleTextureSupport() const { return fRectangleTextureSupport; }
- /// GL_ARB_texture_swizzle
- bool textureSwizzleSupport() const { return fTextureSwizzleSupport; }
-
bool mipMapLevelAndLodControlSupport() const { return fMipMapLevelAndLodControlSupport; }
bool doManualMipmapping() const { return fDoManualMipmapping; }
@@ -502,7 +494,6 @@
bool fPartialFBOReadIsSlow : 1;
bool fBindUniformLocationSupport : 1;
bool fRectangleTextureSupport : 1;
- bool fTextureSwizzleSupport : 1;
bool fMipMapLevelAndLodControlSupport : 1;
bool fRGBAToBGRAReadbackConversionsAreSlow : 1;
bool fUseBufferDataNullHint : 1;
@@ -596,8 +587,6 @@
// verification of color attachment validity is done while flushing. Although only ever
// used in the (sole) rendering thread it can cause races if it is glommed into fFlags.
bool fVerifiedColorAttachment = false;
-
- GrSwizzle fSwizzle;
};
ConfigInfo fConfigTable[kGrPixelConfigCnt];
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 1cfdf3f..a899eb0 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -3079,8 +3079,8 @@
const GrGLTextureParameters::NonsamplerState& oldNonsamplerState =
texture->parameters()->nonsamplerState();
- if (this->glCaps().textureSwizzleSupport()) {
- auto swizzle = this->glCaps().configSwizzle(texture->config());
+ if (!this->caps()->shaderCaps()->textureSwizzleAppliedInShader()) {
+ const auto& swizzle = this->caps()->shaderCaps()->configTextureSwizzle(texture->config());
newNonsamplerState.fSwizzleKey = swizzle.asKey();
if (setAll || swizzle.asKey() != oldNonsamplerState.fSwizzleKey) {
GrGLenum glValues[4];
diff --git a/src/gpu/gl/GrGLUniformHandler.cpp b/src/gpu/gl/GrGLUniformHandler.cpp
index 285da53..dc75504 100644
--- a/src/gpu/gl/GrGLUniformHandler.cpp
+++ b/src/gpu/gl/GrGLUniformHandler.cpp
@@ -78,8 +78,10 @@
sampler.fVariable.setName(mangleName);
sampler.fLocation = -1;
sampler.fVisibility = kFragment_GrShaderFlag;
- fSamplerSwizzles.push_back(swizzle);
- SkASSERT(fSamplers.count() == fSamplerSwizzles.count());
+ if (shaderCaps->textureSwizzleAppliedInShader()) {
+ fSamplerSwizzles.push_back(swizzle);
+ SkASSERT(fSamplers.count() == fSamplerSwizzles.count());
+ }
return GrGLSLUniformHandler::SamplerHandle(fSamplers.count() - 1);
}
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
index 5c76439..654dcbb 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.h
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -56,7 +56,10 @@
}
GrSwizzle samplerSwizzle(SamplerHandle handle) const {
- return this->uniformHandler()->samplerSwizzle(handle);
+ if (this->caps()->shaderCaps()->textureSwizzleAppliedInShader()) {
+ return this->uniformHandler()->samplerSwizzle(handle);
+ }
+ return GrSwizzle::RGBA();
}
// Used to add a uniform for the RenderTarget width (used for sk_Width) without mangling
diff --git a/src/gpu/glsl/GrGLSLUniformHandler.h b/src/gpu/glsl/GrGLSLUniformHandler.h
index e05199d..1a5c951 100644
--- a/src/gpu/glsl/GrGLSLUniformHandler.h
+++ b/src/gpu/glsl/GrGLSLUniformHandler.h
@@ -76,6 +76,7 @@
private:
virtual const GrShaderVar& samplerVariable(SamplerHandle) const = 0;
+ // Only called if GrShaderCaps(:textureSwizzleAppliedInShader() == true.
virtual GrSwizzle samplerSwizzle(SamplerHandle) const = 0;
virtual SamplerHandle addSampler(const GrTexture*, const GrSamplerState&, const char* name,
diff --git a/src/gpu/mtl/GrMtlUniformHandler.mm b/src/gpu/mtl/GrMtlUniformHandler.mm
index c27c6bc..7d90bb4 100644
--- a/src/gpu/mtl/GrMtlUniformHandler.mm
+++ b/src/gpu/mtl/GrMtlUniformHandler.mm
@@ -277,6 +277,7 @@
info.fVariable.addLayoutQualifier(layoutQualifier.c_str());
info.fVisibility = kFragment_GrShaderFlag;
info.fUBOffset = 0;
+ SkASSERT(caps->textureSwizzleAppliedInShader());
fSamplerSwizzles.push_back(swizzle);
SkASSERT(fSamplerSwizzles.count() == fSamplers.count());
return GrGLSLUniformHandler::SamplerHandle(fSamplers.count() - 1);
diff --git a/src/gpu/vk/GrVkUniformHandler.cpp b/src/gpu/vk/GrVkUniformHandler.cpp
index 639af63..0182a80 100644
--- a/src/gpu/vk/GrVkUniformHandler.cpp
+++ b/src/gpu/vk/GrVkUniformHandler.cpp
@@ -288,6 +288,7 @@
SkASSERT(info.fImmutableSampler);
}
+ SkASSERT(shaderCaps->textureSwizzleAppliedInShader());
fSamplerSwizzles.push_back(swizzle);
SkASSERT(fSamplerSwizzles.count() == fSamplers.count());
return GrGLSLUniformHandler::SamplerHandle(fSamplers.count() - 1);