Vulkan: Fix incompatible redefinition of cube faces
The TextureVk::mRedefinedLevels bitmask tracked which levels are
incompatibly redefined, greatly reducing the complexity of dealing with
GL's mutable textures.
It did not however take into account the fact that GL allows each
cubemap face to be separately redefined (unlike 2D arrays, where all
layers are defined together). This change turns the bitmask into an
array of bitmasks. Previously, a single bit represented whether the
level is incompatibly redefined. Now, elements of the array track the
same information for each cube face. For non-cube-map textures, only
element 0 is used.
Bug: chromium:1494664
Change-Id: I69568d3da2391796bf5f01505861fee42c6c8924
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4986289
Reviewed-by: Charlie Lao <cclao@google.com>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
diff --git a/src/libANGLE/angletypes.h b/src/libANGLE/angletypes.h
index 434aa0b..61bbb75 100644
--- a/src/libANGLE/angletypes.h
+++ b/src/libANGLE/angletypes.h
@@ -949,6 +949,9 @@
constexpr size_t kCubeFaceCount = 6;
template <typename T>
+using CubeFaceArray = std::array<T, kCubeFaceCount>;
+
+template <typename T>
using TextureTypeMap = angle::PackedEnumMap<TextureType, T>;
using TextureMap = TextureTypeMap<BindingPointer<Texture>>;
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.cpp b/src/libANGLE/renderer/vulkan/TextureVk.cpp
index 17d4b94..83bdcac 100644
--- a/src/libANGLE/renderer/vulkan/TextureVk.cpp
+++ b/src/libANGLE/renderer/vulkan/TextureVk.cpp
@@ -471,6 +471,36 @@
ASSERT(GetRGBAEmulationDstFormat(formatID) != angle::FormatID::NONE);
return true;
}
+
+bool HasAnyRedefinedLevels(const gl::CubeFaceArray<gl::TexLevelMask> &redefinedLevels)
+{
+ for (gl::TexLevelMask faceRedefinedLevels : redefinedLevels)
+ {
+ if (faceRedefinedLevels.any())
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool IsLevelRedefined(const gl::CubeFaceArray<gl::TexLevelMask> &redefinedLevels,
+ gl::TextureType textureType,
+ gl::LevelIndex level)
+{
+ gl::TexLevelMask redefined = redefinedLevels[0];
+
+ if (textureType == gl::TextureType::CubeMap)
+ {
+ for (size_t face = 1; face < gl::kCubeFaceCount; ++face)
+ {
+ redefined |= redefinedLevels[face];
+ }
+ }
+
+ return redefined.test(level.get());
+}
} // anonymous namespace
// TextureVk implementation.
@@ -736,7 +766,7 @@
ASSERT(mImage->valid());
ASSERT(IsTextureLevelInAllocatedImage(*mImage, textureLevelIndexGL));
ASSERT(mImage->getActualFormatID() == dstImageFormatID);
- ASSERT(!mRedefinedLevels.test(textureLevelIndexGL.get()));
+ ASSERT(!IsLevelRedefined(mRedefinedLevels, mState.getType(), textureLevelIndexGL));
return false;
}
@@ -763,7 +793,7 @@
// Otherwise, it can only be directly applied to the image if the level is not previously
// incompatibly redefined.
- return mRedefinedLevels.test(textureLevelIndexGL.get());
+ return IsLevelRedefined(mRedefinedLevels, mState.getType(), textureLevelIndexGL);
}
angle::Result TextureVk::setSubImageImpl(const gl::Context *context,
@@ -1629,7 +1659,7 @@
}
ASSERT(mState.getImmutableFormat());
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
ANGLE_TRY(initImage(contextVk, format.getIntendedFormatID(),
format.getActualImageFormatID(getRequiredImageAccess()),
ImageMipLevels::FullMipChainForGenerateMipmap));
@@ -1814,7 +1844,7 @@
mBufferViews.release(contextVk);
onStateChange(angle::SubjectMessage::SubjectChanged);
}
- mRedefinedLevels.reset();
+ mRedefinedLevels = {};
mDescriptorSetCacheManager.releaseKeys(contextVk->getRenderer());
}
@@ -1924,7 +1954,7 @@
// If there are any staged changes for this index, we can remove them since we're going to
// override them with this call.
gl::LevelIndex levelIndexGL(index.getLevelIndex());
- uint32_t layerIndex = index.hasLayer() ? index.getLayerIndex() : 0;
+ const uint32_t layerIndex = index.hasLayer() ? index.getLayerIndex() : 0;
if (gl::IsArrayTextureType(index.getType()))
{
// A multi-layer texture is being redefined, remove all updates to this level; the
@@ -1964,11 +1994,12 @@
// image.
// - Otherwise keep the image intact (another mip may be the source of a copy), and
// make sure any updates to this level are staged.
- bool isInAllocatedImage = IsTextureLevelInAllocatedImage(*mImage, levelIndexGL);
- bool isCompatibleRedefinition =
+ const bool isInAllocatedImage = IsTextureLevelInAllocatedImage(*mImage, levelIndexGL);
+ const bool isCompatibleRedefinition =
isInAllocatedImage && IsTextureLevelDefinitionCompatibleWithImage(
*mImage, levelIndexGL, size, format.getIntendedFormatID(),
format.getActualImageFormatID(getRequiredImageAccess()));
+ const bool isCubeMap = index.getType() == gl::TextureType::CubeMap;
// Mark the level as incompatibly redefined if that's the case. Note that if the level
// was previously incompatibly defined, then later redefined to be compatible, the
@@ -1977,15 +2008,20 @@
{
// Immutable texture should never have levels redefined.
ASSERT(isCompatibleRedefinition || !mState.getImmutableFormat());
- mRedefinedLevels.set(levelIndexGL.get(), !isCompatibleRedefinition);
+
+ const uint32_t redefinedFace = isCubeMap ? layerIndex : 0;
+ mRedefinedLevels[redefinedFace].set(levelIndexGL.get(), !isCompatibleRedefinition);
}
- bool isUpdateToSingleLevelImage =
+ const bool isUpdateToSingleLevelImage =
mImage->getLevelCount() == 1 && mImage->getFirstAllocatedLevel() == levelIndexGL;
// If incompatible, and redefining the single-level image, release it so it can be
// recreated immediately. This is an optimization to avoid an extra copy.
- if (!isCompatibleRedefinition && isUpdateToSingleLevelImage)
+ //
+ // This is not done for cubemaps because every face may be separately redefined. Note
+ // that this is not possible for texture arrays in general.
+ if (!isCompatibleRedefinition && isUpdateToSingleLevelImage && !isCubeMap)
{
releaseImage(contextVk);
}
@@ -2239,7 +2275,7 @@
sourceDepthPitch, imageData + bufferOffset));
}
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
return flushImageStagedUpdates(contextVk);
}
@@ -2356,7 +2392,7 @@
// This path is only called when switching from !owned to owned, in which case if any level was
// redefined it's already released and deleted by TextureVk::redefineLevel().
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
// Create a temp copy of srcImage for staging.
std::unique_ptr<vk::RefCounted<vk::ImageHelper>> stagingImage;
@@ -2407,9 +2443,7 @@
return angle::Result::Continue;
}
-angle::Result TextureVk::reinitImageAsRenderable(ContextVk *contextVk,
- const vk::Format &format,
- gl::TexLevelMask skipLevelsMask)
+angle::Result TextureVk::reinitImageAsRenderable(ContextVk *contextVk, const vk::Format &format)
{
ASSERT(mImage->valid());
RendererVk *renderer = contextVk->getRenderer();
@@ -2417,14 +2451,6 @@
const uint32_t levelCount = mImage->getLevelCount();
const uint32_t layerCount = mImage->getLayerCount();
- // Nothing to do if every level must be skipped
- gl::TexLevelMask levelsMask(angle::BitMask<uint32_t>(levelCount)
- << mImage->getFirstAllocatedLevel().get());
- if ((~skipLevelsMask & levelsMask).none())
- {
- return angle::Result::Continue;
- }
-
// Make sure the source is initialized and its staged updates are flushed.
ANGLE_TRY(flushImageStagedUpdates(contextVk));
@@ -2435,7 +2461,8 @@
// with draw path is that in the multiple level/layer case, we have to do copy in a loop.
// Currently copySubImageImplWithDraw() calls ensureImageInitalized which forces flush out
// staged updates that we just staged inside the loop which is wrong.
- if (levelCount == 1 && layerCount == 1)
+ if (levelCount == 1 && layerCount == 1 &&
+ !IsLevelRedefined(mRedefinedLevels, mState.getType(), mImage->getFirstAllocatedLevel()))
{
ANGLE_VK_PERF_WARNING(contextVk, GL_DEBUG_SEVERITY_LOW,
"Copying image data due to texture format fallback");
@@ -2463,7 +2490,7 @@
for (vk::LevelIndex levelVk(0); levelVk < vk::LevelIndex(levelCount); ++levelVk)
{
gl::LevelIndex levelGL = mImage->toGLLevel(levelVk);
- if (skipLevelsMask.test(levelGL.get()))
+ if (IsLevelRedefined(mRedefinedLevels, mState.getType(), levelGL))
{
continue;
}
@@ -2528,7 +2555,7 @@
{
if (!mImage->valid())
{
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
return angle::Result::Continue;
}
@@ -2547,7 +2574,7 @@
// If any level was redefined but the image was not owned by the Texture, it's already
// released and deleted by TextureVk::redefineLevel().
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
// Save previousFirstAllocateLevel before mImage becomes invalid
gl::LevelIndex previousFirstAllocateLevel = mImage->getFirstAllocatedLevel();
@@ -2572,7 +2599,7 @@
const vk::Format &format = getBaseLevelFormat(contextVk->getRenderer());
if (mImage->getActualFormatID() != format.getActualImageFormatID(getRequiredImageAccess()))
{
- ANGLE_TRY(reinitImageAsRenderable(contextVk, format, mRedefinedLevels));
+ ANGLE_TRY(reinitImageAsRenderable(contextVk, format));
}
else
{
@@ -2705,7 +2732,7 @@
if (!mImage->valid())
{
- ASSERT(!mRedefinedLevels.any());
+ ASSERT(!HasAnyRedefinedLevels(mRedefinedLevels));
const vk::Format &format = getBaseLevelFormat(contextVk->getRenderer());
ANGLE_TRY(initImage(contextVk, format.getIntendedFormatID(),
@@ -2907,11 +2934,14 @@
// Remove (baseLevel, maxLevel] from mRedefinedLevels. These levels are no longer incompatibly
// defined if they previously were. The corresponding bits in mRedefinedLevels should be
// cleared.
- mRedefinedLevels &= ~levelsMask;
+ for (size_t face = 0; face < gl::kCubeFaceCount; ++face)
+ {
+ mRedefinedLevels[face] &= ~levelsMask;
+ }
// If generating mipmap and base level is incompatibly redefined, the image is going to be
// recreated. Don't try to preserve the other mips.
- if (mRedefinedLevels.test(baseLevel.get()))
+ if (IsLevelRedefined(mRedefinedLevels, mState.getType(), baseLevel))
{
ASSERT(!mState.getImmutableFormat());
releaseImage(contextVk);
@@ -3044,7 +3074,7 @@
// twice, which incurs unnecessary copies. This is not expected to be happening in real
// applications.
if (oldUsageFlags != mImageUsageFlags || oldCreateFlags != mImageCreateFlags ||
- mRedefinedLevels.any() || isMipmapEnabledByMinFilter)
+ HasAnyRedefinedLevels(mRedefinedLevels) || isMipmapEnabledByMinFilter)
{
ANGLE_TRY(respecifyImageStorage(contextVk));
}
@@ -3671,7 +3701,7 @@
}
onStateChange(angle::SubjectMessage::SubjectChanged);
- mRedefinedLevels.reset();
+ mRedefinedLevels = {};
}
void TextureVk::releaseImageViews(ContextVk *contextVk)
@@ -4137,7 +4167,8 @@
releaseImageViews(contextVk);
// Make the image stage itself as updates to its levels.
ASSERT(!mImageSiblingSerial.valid());
- mImage->stageSelfAsSubresourceUpdates(contextVk, mImage->getLevelCount(), mRedefinedLevels);
+ mImage->stageSelfAsSubresourceUpdates(contextVk, mImage->getLevelCount(), mState.getType(),
+ mRedefinedLevels);
}
void TextureVk::updateCachedImageViewSerials()
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.h b/src/libANGLE/renderer/vulkan/TextureVk.h
index 890cdf5..fb102cd 100644
--- a/src/libANGLE/renderer/vulkan/TextureVk.h
+++ b/src/libANGLE/renderer/vulkan/TextureVk.h
@@ -492,9 +492,7 @@
gl::LevelIndex previousFirstAllocateLevel,
vk::ImageHelper *srcImage,
vk::ImageHelper *dstImage);
- angle::Result reinitImageAsRenderable(ContextVk *contextVk,
- const vk::Format &format,
- gl::TexLevelMask skipLevelsMask);
+ angle::Result reinitImageAsRenderable(ContextVk *contextVk, const vk::Format &format);
angle::Result initImageViews(ContextVk *contextVk, uint32_t levelCount);
void initSingleLayerRenderTargets(ContextVk *contextVk,
GLuint layerCount,
@@ -641,16 +639,19 @@
// If an image level is incompatibly redefined, the image lives through the call that did this
// (i.e. set and copy levels), because the image may be used by the framebuffer in the very same
// call. As a result, updates to this redefined level are staged (in both the call that
- // redefines it, and any future calls such as subimage updates). This bitset flags redefined
- // levels so that their updates will be force-staged until image is recreated.
+ // redefines it, and any future calls such as subimage updates). This array flags redefined
+ // levels so that their updates will be force-staged until image is recreated. Each member of
+ // the array is a bitmask per level, and it's an array of cube faces because GL allows
+ // redefining each cube map face separately. For other texture types, only index 0 is
+ // meaningful as all array levels are redefined simultaneously.
//
// In common cases with mipmapped textures, the base/max level would need adjusting as the
// texture is no longer mip-complete. However, if every level is redefined such that at the end
- // the image becomes mip-complete again, no reinitialization of the image is done. This bitset
+ // the image becomes mip-complete again, no reinitialization of the image is done. This array
// is additionally used to ensure the image is recreated in the next syncState, if not already.
//
- // Note: this bitmask is for gl::LevelIndex, not vk::LevelIndex
- gl::TexLevelMask mRedefinedLevels;
+ // Note: the elements of this array are bitmasks indexed by gl::LevelIndex, not vk::LevelIndex
+ gl::CubeFaceArray<gl::TexLevelMask> mRedefinedLevels;
angle::ObserverBinding mImageObserverBinding;
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.cpp b/src/libANGLE/renderer/vulkan/vk_helpers.cpp
index 3c0ad07..2dc3ce0 100644
--- a/src/libANGLE/renderer/vulkan/vk_helpers.cpp
+++ b/src/libANGLE/renderer/vulkan/vk_helpers.cpp
@@ -1018,6 +1018,16 @@
const VkImageLayout *haystackEnd = haystack + haystackCount;
return std::find(haystack, haystackEnd, needle) != haystackEnd;
}
+
+gl::TexLevelMask AggregateSkipLevels(const gl::CubeFaceArray<gl::TexLevelMask> &skipLevels)
+{
+ gl::TexLevelMask skipLevelsAllFaces = skipLevels[0];
+ for (size_t face = 1; face < gl::kCubeFaceCount; ++face)
+ {
+ skipLevelsAllFaces |= skipLevels[face];
+ }
+ return skipLevelsAllFaces;
+}
} // anonymous namespace
// This is an arbitrary max. We can change this later if necessary.
@@ -8535,14 +8545,19 @@
return true;
}
-void ImageHelper::stageSelfAsSubresourceUpdates(ContextVk *contextVk,
- uint32_t levelCount,
- gl::TexLevelMask skipLevelsMask)
+void ImageHelper::stageSelfAsSubresourceUpdates(
+ ContextVk *contextVk,
+ uint32_t levelCount,
+ gl::TextureType textureType,
+ const gl::CubeFaceArray<gl::TexLevelMask> &skipLevels)
{
// Nothing to do if every level must be skipped
- gl::TexLevelMask levelsMask(angle::BitMask<uint32_t>(levelCount) << mFirstAllocatedLevel.get());
- if ((~skipLevelsMask & levelsMask).none())
+ const gl::TexLevelMask levelsMask(angle::BitMask<uint32_t>(levelCount)
+ << mFirstAllocatedLevel.get());
+ const gl::TexLevelMask skipLevelsAllFaces = AggregateSkipLevels(skipLevels);
+
+ if ((~skipLevelsAllFaces & levelsMask).none())
{
return;
}
@@ -8594,16 +8609,29 @@
for (LevelIndex levelVk(0); levelVk < LevelIndex(levelCount); ++levelVk)
{
gl::LevelIndex levelGL = toGLLevel(levelVk);
- if (skipLevelsMask.test(levelGL.get()))
+ if (!skipLevelsAllFaces.test(levelGL.get()))
{
- continue;
+ const gl::ImageIndex index =
+ gl::ImageIndex::Make2DArrayRange(levelGL.get(), 0, mLayerCount);
+
+ stageSubresourceUpdateFromImage(prevImage.get(), index, levelVk, gl::kOffsetZero,
+ getLevelExtents(levelVk), mImageType);
}
+ else if (textureType == gl::TextureType::CubeMap)
+ {
+ for (uint32_t face = 0; face < gl::kCubeFaceCount; ++face)
+ {
+ if (!skipLevels[face][levelGL.get()])
+ {
+ const gl::ImageIndex index =
+ gl::ImageIndex::Make2DArrayRange(levelGL.get(), face, 1);
- const gl::ImageIndex index =
- gl::ImageIndex::Make2DArrayRange(levelGL.get(), 0, mLayerCount);
-
- stageSubresourceUpdateFromImage(prevImage.get(), index, levelVk, gl::kOffsetZero,
- getLevelExtents(levelVk), mImageType);
+ stageSubresourceUpdateFromImage(prevImage.get(), index, levelVk,
+ gl::kOffsetZero, getLevelExtents(levelVk),
+ mImageType);
+ }
+ }
+ }
}
ASSERT(levelCount > 0);
@@ -8684,7 +8712,7 @@
gl::LevelIndex levelGLEnd,
uint32_t layerStart,
uint32_t layerEnd,
- gl::TexLevelMask skipLevelsMask)
+ const gl::CubeFaceArray<gl::TexLevelMask> &skipLevels)
{
RendererVk *renderer = contextVk->getRenderer();
@@ -8693,7 +8721,8 @@
return angle::Result::Continue;
}
- removeSupersededUpdates(contextVk, skipLevelsMask);
+ const gl::TexLevelMask skipLevelsAllFaces = AggregateSkipLevels(skipLevels);
+ removeSupersededUpdates(contextVk, skipLevelsAllFaces);
// If a clear is requested and we know it was previously cleared with the same value, we drop
// the clear.
@@ -8792,7 +8821,7 @@
// them. This can happen when recreating an image that has been partially incompatibly
// redefined, in which case only updates to the levels that haven't been redefined
// should be flushed.
- if (areUpdateLayersOutsideRange || skipLevelsMask.test(updateMipLevelGL.get()))
+ if (areUpdateLayersOutsideRange || skipLevelsAllFaces.test(updateMipLevelGL.get()))
{
updatesToKeep.emplace_back(std::move(update));
continue;
@@ -9275,7 +9304,8 @@
mTotalStagedBufferUpdateSize -= supersededUpdateSize;
}
-void ImageHelper::removeSupersededUpdates(ContextVk *contextVk, gl::TexLevelMask skipLevelsMask)
+void ImageHelper::removeSupersededUpdates(ContextVk *contextVk,
+ const gl::TexLevelMask skipLevelsAllFaces)
{
ASSERT(validateSubresourceUpdateRefCountsConsistent());
@@ -9284,7 +9314,7 @@
gl::LevelIndex levelGL = toGLLevel(levelVk);
std::vector<SubresourceUpdate> *levelUpdates = getLevelUpdates(levelGL);
if (levelUpdates == nullptr || levelUpdates->size() == 0 ||
- skipLevelsMask.test(levelGL.get()))
+ skipLevelsAllFaces.test(levelGL.get()))
{
// There are no valid updates to process, continue.
continue;
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.h b/src/libANGLE/renderer/vulkan/vk_helpers.h
index 63112ce..5265738 100644
--- a/src/libANGLE/renderer/vulkan/vk_helpers.h
+++ b/src/libANGLE/renderer/vulkan/vk_helpers.h
@@ -2264,7 +2264,8 @@
// - Image respecification, where every level (other than those explicitly skipped) is staged
void stageSelfAsSubresourceUpdates(ContextVk *contextVk,
uint32_t levelCount,
- gl::TexLevelMask skipLevelsMask);
+ gl::TextureType textureType,
+ const gl::CubeFaceArray<gl::TexLevelMask> &skipLevels);
// Flush staged updates for a single subresource. Can optionally take a parameter to defer
// clears to a subsequent RenderPass load op.
@@ -2283,7 +2284,7 @@
gl::LevelIndex levelGLEnd,
uint32_t layerStart,
uint32_t layerEnd,
- gl::TexLevelMask skipLevelsMask);
+ const gl::CubeFaceArray<gl::TexLevelMask> &skipLevels);
// Creates a command buffer and flushes all staged updates. This is used for one-time
// initialization of resources that we don't expect to accumulate further staged updates, such
@@ -2625,7 +2626,7 @@
// Called from flushStagedUpdates, removes updates that are later superseded by another. This
// cannot be done at the time the updates were staged, as the image is not created (and thus the
// extents are not known).
- void removeSupersededUpdates(ContextVk *contextVk, gl::TexLevelMask skipLevelsMask);
+ void removeSupersededUpdates(ContextVk *contextVk, const gl::TexLevelMask skipLevelsAllFaces);
void initImageMemoryBarrierStruct(Context *context,
VkImageAspectFlags aspectMask,
diff --git a/src/tests/angle_end2end_tests_expectations.txt b/src/tests/angle_end2end_tests_expectations.txt
index 4ded60d..bbbf53c 100644
--- a/src/tests/angle_end2end_tests_expectations.txt
+++ b/src/tests/angle_end2end_tests_expectations.txt
@@ -66,6 +66,8 @@
6173 WIN INTEL OPENGL : GLSLTest_ES31.BoolInInterfaceBlocks/* = SKIP
6217 WIN INTEL OPENGL : GLSLTest_ES31.StorageBufferBoolVectorPassedToFunctions/* = SKIP
7143 WIN INTEL OPENGL : GLSLTest.AliasingFunctionOutParamAndGlobal/* = SKIP
+8399 WIN INTEL OPENGL : TextureCubeTestES3.IncompatibleLayerABThenCompatibleLayerAB/* = SKIP
+8399 WIN INTEL OPENGL : TextureCubeTestES3.IncompatibleLayerABThenCompatibleLayerABSingleLevel/* = SKIP
6826 WIN NVIDIA OPENGL : GLSLTest.VectorAndMatrixScalarizationDoesNotAffectRendering/* = SKIP
6826 WIN NVIDIA GLES : GLSLTest.VectorAndMatrixScalarizationDoesNotAffectRendering/* = SKIP
4716 WIN NVIDIA GLES : CopyTextureTest.CopyOutsideMipmap/* = SKIP
diff --git a/src/tests/gl_tests/TextureTest.cpp b/src/tests/gl_tests/TextureTest.cpp
index 7a1b228..7acb727 100644
--- a/src/tests/gl_tests/TextureTest.cpp
+++ b/src/tests/gl_tests/TextureTest.cpp
@@ -904,12 +904,27 @@
R"(precision highp float;
uniform sampler2D tex2D;
uniform samplerCube texCube;
+ uniform int cubeFace;
varying vec2 texcoord;
void main()
{
gl_FragColor = texture2D(tex2D, texcoord);
- gl_FragColor += textureCube(texCube, vec3(texcoord, 0));
+
+ vec2 scaled = vec2(1) - vec2(2) * texcoord.xy;
+ vec3 cubecoord = vec3(1, scaled.xy);
+ if (cubeFace == 1)
+ cubecoord = vec3(-1, scaled.xy);
+ else if (cubeFace == 2)
+ cubecoord = vec3(scaled.x, 1, scaled.y);
+ else if (cubeFace == 3)
+ cubecoord = vec3(scaled.x, -1, scaled.y);
+ else if (cubeFace == 4)
+ cubecoord = vec3(scaled.xy, 1);
+ else if (cubeFace == 5)
+ cubecoord = vec3(scaled.xy, -1);
+
+ gl_FragColor += textureCube(texCube, cubecoord);
})";
}
@@ -934,6 +949,8 @@
ASSERT_NE(-1, mTexture2DUniformLocation);
mTextureCubeUniformLocation = glGetUniformLocation(mProgram, "texCube");
ASSERT_NE(-1, mTextureCubeUniformLocation);
+ mTextureCubeFaceUniformLocation = glGetUniformLocation(mProgram, "cubeFace");
+ ASSERT_NE(-1, mTextureCubeFaceUniformLocation);
}
void testTearDown() override
@@ -946,9 +963,10 @@
GLuint mTextureCube;
GLint mTexture2DUniformLocation;
GLint mTextureCubeUniformLocation;
+ GLint mTextureCubeFaceUniformLocation;
};
-class TextureCubeTestES3 : public ANGLETest<>
+class TextureCubeTestES3 : public TextureCubeTest
{
protected:
TextureCubeTestES3() {}
@@ -2279,6 +2297,16 @@
texData[1] = 120;
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
texData);
+ glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ texData);
+ glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ texData);
+ glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ texData);
+ glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ texData);
+ glTexSubImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ texData);
EXPECT_GL_ERROR(GL_NO_ERROR);
glUseProgram(mProgram);
@@ -10598,6 +10626,225 @@
EXPECT_PIXEL_COLOR_EQ(0, 0, angle::GLColor::red);
}
+// Test creating a mutable cubemap, committing it, and then incomaptibly redefining one layer, while
+// compatibly redefining another layer.
+TEST_P(TextureCubeTestES3, IncompatibleLayerAThenCompatibleLayerB)
+{
+ GLTexture tex;
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ std::vector<uint32_t> data(32 * 32 * 4, 0xC00FFC00);
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 32, 32, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ EXPECT_GL_NO_ERROR();
+}
+
+// Test creating a mutable cubemap, committing it, and then comaptibly redefining one layer, while
+// incompatibly redefining another layer.
+TEST_P(TextureCubeTestES3, CompatibleLayerAThenIncompatibleLayerB)
+{
+ GLTexture tex;
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ std::vector<uint32_t> data(32 * 32 * 4, 0xC00FFC00);
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 32, 32, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ EXPECT_GL_NO_ERROR();
+}
+
+// Test creating a mutable cubemap, committing it, and then incomaptibly redefining two layers,
+// while compatibly redefining another layer.
+TEST_P(TextureCubeTestES3, IncompatibleLayerABThenCompatibleLayerC)
+{
+ GLTexture tex;
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ std::vector<uint32_t> data(32 * 32 * 4, 0xC00FFC00);
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, 32, 32, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, 32, 32, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, 16, 16, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ EXPECT_GL_NO_ERROR();
+}
+
+// Test creating a mutable cubemap, committing it, and then incomaptibly redefining two layers and
+// compatibly redefining them again.
+TEST_P(TextureCubeTestES3, IncompatibleLayerABThenCompatibleLayerAB)
+{
+ GLTexture tex;
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ constexpr uint32_t kSize = 64;
+
+ std::vector<uint32_t> data(kSize * kSize * 4 * 4, 0xC00FFC00);
+ std::vector<uint32_t> data2(kSize * kSize * 4 * 4, 0xC00003FF);
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize * 2, kSize * 2, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize * 2, kSize * 2, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data2.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data2.data());
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, 0);
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ glUseProgram(mProgram);
+ glUniform1i(mTexture2DUniformLocation, 0);
+ glUniform1i(mTextureCubeUniformLocation, 1);
+
+ const int w = getWindowWidth();
+ const int h = getWindowHeight();
+
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ glUniform1i(mTextureCubeFaceUniformLocation, i);
+ glClear(GL_COLOR_BUFFER_BIT);
+ drawQuad(mProgram, "position", 0.5f);
+
+ const bool expectRed = i == 2 || i == 5;
+ const GLColor expect = expectRed ? GLColor::red : GLColor::green;
+ EXPECT_PIXEL_RECT_EQ(2, 2, w - 4, h - 4, expect);
+ EXPECT_GL_NO_ERROR();
+ }
+}
+
+// Similar to IncompatibleLayerABThenCompatibleLayerAB, but with a single-level texture
+TEST_P(TextureCubeTestES3, IncompatibleLayerABThenCompatibleLayerABSingleLevel)
+{
+ GLTexture tex;
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ constexpr uint32_t kSize = 64;
+
+ std::vector<uint32_t> data(kSize * kSize * 4 * 4, 0xC00FFC00);
+ std::vector<uint32_t> data2(kSize * kSize * 4 * 4, 0xC00003FF);
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, 0);
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
+
+ glUseProgram(mProgram);
+ glUniform1i(mTexture2DUniformLocation, 0);
+ glUniform1i(mTextureCubeUniformLocation, 1);
+
+ const int w = getWindowWidth();
+ const int h = getWindowHeight();
+
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ glUniform1i(mTextureCubeFaceUniformLocation, i);
+ glClear(GL_COLOR_BUFFER_BIT);
+ drawQuad(mProgram, "position", 0.5f);
+
+ EXPECT_PIXEL_RECT_EQ(0, 0, w, h, GLColor::green);
+ EXPECT_GL_NO_ERROR();
+ }
+
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize * 2, kSize * 2, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize * 2, kSize * 2, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data2.data());
+ glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GL_RGB10_A2, kSize, kSize, 0, GL_RGBA,
+ GL_UNSIGNED_INT_2_10_10_10_REV, data2.data());
+
+ for (uint32_t i = 0; i < 6; ++i)
+ {
+ glUniform1i(mTextureCubeFaceUniformLocation, i);
+ glClear(GL_COLOR_BUFFER_BIT);
+ drawQuad(mProgram, "position", 0.5f);
+
+ const bool expectRed = i == 2 || i == 5;
+ const GLColor expect = expectRed ? GLColor::red : GLColor::green;
+ EXPECT_PIXEL_RECT_EQ(2, 2, w - 4, h - 4, expect);
+ EXPECT_GL_NO_ERROR();
+ }
+}
+
// Verify that using negative texture base level and max level generates GL_INVALID_VALUE.
TEST_P(Texture2DTestES3, NegativeTextureBaseLevelAndMaxLevel)
{
