Rename constant to kCubeFaceCount.

src/libANGLE/ImageIndex.cpp

@@ -118,7 +118,7 @@ TextureTarget ImageIndex::getTarget() const
 GLint ImageIndex::cubeMapFaceIndex() const
 {
     ASSERT(mType == TextureType::CubeMap);
-    ASSERT(mLayerIndex == kEntireLevel || mLayerIndex < static_cast<GLint>(CUBE_FACE_COUNT));
+    ASSERT(mLayerIndex == kEntireLevel || mLayerIndex < static_cast<GLint>(kCubeFaceCount));
     return mLayerIndex;
 }
 
@@ -174,7 +174,7 @@ ImageIndex ImageIndex::MakeFromType(TextureType type,
                                     GLint layerCount)
 {
     GLint overrideLayerCount =
-        (type == TextureType::CubeMap && layerIndex == kEntireLevel ? CUBE_FACE_COUNT : layerCount);
+        (type == TextureType::CubeMap && layerIndex == kEntireLevel ? kCubeFaceCount : layerCount);
     return ImageIndex(type, levelIndex, layerIndex, overrideLayerCount);
 }
 

src/libANGLE/angletypes.h

@@ -315,7 +315,7 @@ struct ComponentTypeMask final
 
 using ContextID = uintptr_t;
 
-constexpr size_t CUBE_FACE_COUNT = 6;
+constexpr size_t kCubeFaceCount = 6;
 
 using TextureMap = angle::PackedEnumMap<TextureType, BindingPointer<Texture>>;
 

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -1580,7 +1580,7 @@ TextureD3D_Cube::~TextureD3D_Cube()
 ImageD3D *TextureD3D_Cube::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(layer >= 0 && layer < 6);
+    ASSERT(layer >= 0 && static_cast<size_t>(layer) < gl::kCubeFaceCount);
     return mImageArray[layer][level].get();
 }
 
@@ -1594,7 +1594,7 @@ ImageD3D *TextureD3D_Cube::getImage(const gl::ImageIndex &index) const
 GLsizei TextureD3D_Cube::getLayerCount(int level) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    return 6;
+    return gl::kCubeFaceCount;
 }
 
 GLenum TextureD3D_Cube::getInternalFormat(GLint level, GLint layer) const
@@ -1912,7 +1912,7 @@ gl::Error TextureD3D_Cube::setStorage(const gl::Context *context,
     for (size_t level = 0; level < levels; level++)
     {
         GLsizei mipSize = std::max(1, size.width >> level);
-        for (int faceIndex = 0; faceIndex < 6; faceIndex++)
+        for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++)
         {
             mImageArray[faceIndex][level]->redefine(gl::TextureType::CubeMap, internalFormat,
                                                     gl::Extents(mipSize, mipSize, 1), true);
@@ -1921,7 +1921,7 @@ gl::Error TextureD3D_Cube::setStorage(const gl::Context *context,
 
     for (size_t level = levels; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
-        for (int faceIndex = 0; faceIndex < 6; faceIndex++)
+        for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++)
         {
             mImageArray[faceIndex][level]->redefine(gl::TextureType::CubeMap, GL_NONE,
                                                     gl::Extents(0, 0, 0), true);
@@ -1957,7 +1957,7 @@ bool TextureD3D_Cube::isCubeComplete() const
         return false;
     }
 
-    for (int faceIndex = 1; faceIndex < 6; faceIndex++)
+    for (size_t faceIndex = 1; faceIndex < gl::kCubeFaceCount; faceIndex++)
     {
         const ImageD3D &faceBaseImage = *mImageArray[faceIndex][getBaseLevel()];
 
@@ -1990,7 +1990,7 @@ angle::Result TextureD3D_Cube::initMipmapImages(const gl::Context *context)
     const GLuint maxLevel  = mState.getMipmapMaxLevel();
     // Purge array levels baseLevel + 1 through q and reset them to represent the generated mipmap
     // levels.
-    for (int faceIndex = 0; faceIndex < 6; faceIndex++)
+    for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++)
     {
         for (GLuint level = baseLevel + 1; level <= maxLevel; level++)
         {
@@ -2063,7 +2063,7 @@ angle::Result TextureD3D_Cube::createCompleteStorage(bool renderTarget,
         // If any of the CPU images (levels >= 1) are dirty, then the textureStorage should use the mipped texture to begin with.
         // Otherwise, it should use the level-zero-only texture.
         hintLevelZeroOnly = true;
-        for (int faceIndex = 0; faceIndex < 6 && hintLevelZeroOnly; faceIndex++)
+        for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount && hintLevelZeroOnly; faceIndex++)
         {
             for (int level = 1; level < levels && hintLevelZeroOnly; level++)
             {
@@ -2084,7 +2084,7 @@ angle::Result TextureD3D_Cube::setCompleteTexStorage(const gl::Context *context,
 {
     if (newCompleteTexStorage && newCompleteTexStorage->isManaged())
     {
-        for (int faceIndex = 0; faceIndex < 6; faceIndex++)
+        for (size_t faceIndex = 0; faceIndex < gl::kCubeFaceCount; faceIndex++)
         {
             for (int level = 0; level < newCompleteTexStorage->getLevelCount(); level++)
             {
@@ -2110,7 +2110,7 @@ angle::Result TextureD3D_Cube::updateStorage(const gl::Context *context)
 
     ASSERT(mTexStorage != nullptr);
     GLint storageLevels = mTexStorage->getLevelCount();
-    for (int face = 0; face < 6; face++)
+    for (size_t face = 0; face < gl::kCubeFaceCount; face++)
     {
         for (int level = 0; level < storageLevels; level++)
         {
@@ -2136,7 +2136,8 @@ bool TextureD3D_Cube::isFaceLevelComplete(int faceIndex, int level) const
     {
         return false;
     }
-    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
+    ASSERT(level >= 0 && static_cast<size_t>(faceIndex) < gl::kCubeFaceCount &&
+           level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
 
     if (isImmutable())
@@ -2184,7 +2185,8 @@ angle::Result TextureD3D_Cube::updateStorageFaceLevel(const gl::Context *context
                                                       int faceIndex,
                                                       int level)
 {
-    ASSERT(level >= 0 && faceIndex < 6 && level < static_cast<int>(mImageArray[faceIndex].size()) &&
+    ASSERT(level >= 0 && static_cast<size_t>(faceIndex) < gl::kCubeFaceCount &&
+           level < static_cast<int>(mImageArray[faceIndex].size()) &&
            mImageArray[faceIndex][level] != nullptr);
     ImageD3D *image = mImageArray[faceIndex][level].get();
 
@@ -2253,7 +2255,7 @@ void TextureD3D_Cube::markAllImagesDirty()
 {
     for (int dirtyLevel = 0; dirtyLevel < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; dirtyLevel++)
     {
-        for (int dirtyFace = 0; dirtyFace < 6; dirtyFace++)
+        for (size_t dirtyFace = 0; dirtyFace < gl::kCubeFaceCount; dirtyFace++)
         {
             mImageArray[dirtyFace][dirtyLevel]->markDirty();
         }

src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp

@@ -1884,14 +1884,14 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer,
 {
     for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
-        for (unsigned int face = 0; face < gl::CUBE_FACE_COUNT; face++)
+        for (unsigned int face = 0; face < gl::kCubeFaceCount; face++)
         {
             mAssociatedImages[face][level] = nullptr;
             mRenderTarget[face][level]     = nullptr;
         }
     }
 
-    for (unsigned int face = 0; face < gl::CUBE_FACE_COUNT; face++)
+    for (unsigned int face = 0; face < gl::kCubeFaceCount; face++)
     {
         mLevelZeroRenderTarget[face] = nullptr;
     }
@@ -1913,7 +1913,7 @@ angle::Result TextureStorage11_Cube::onDestroy(const gl::Context *context)
 {
     for (unsigned int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
     {
-        for (unsigned int face = 0; face < gl::CUBE_FACE_COUNT; face++)
+        for (unsigned int face = 0; face < gl::kCubeFaceCount; face++)
         {
             if (mAssociatedImages[face][level] != nullptr)
             {
@@ -2055,11 +2055,11 @@ void TextureStorage11_Cube::associateImage(Image11 *image, const gl::ImageIndex
     const GLint layerTarget = index.cubeMapFaceIndex();
 
     ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT));
+    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount));
 
     if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
     {
-        if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT))
+        if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount))
         {
             mAssociatedImages[layerTarget][level] = image;
         }
@@ -2073,7 +2073,7 @@ void TextureStorage11_Cube::verifyAssociatedImageValid(const gl::ImageIndex &ind
     const GLint layerTarget = index.cubeMapFaceIndex();
 
     ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT));
+    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount));
     // This validation check should never return false. It means the Image/TextureStorage
     // association is broken.
     ASSERT(mAssociatedImages[layerTarget][level] == expectedImage);
@@ -2086,7 +2086,7 @@ void TextureStorage11_Cube::disassociateImage(const gl::ImageIndex &index, Image
     const GLint layerTarget = index.cubeMapFaceIndex();
 
     ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT));
+    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount));
     ASSERT(mAssociatedImages[layerTarget][level] == expectedImage);
     mAssociatedImages[layerTarget][level] = nullptr;
 }
@@ -2101,11 +2101,11 @@ angle::Result TextureStorage11_Cube::releaseAssociatedImage(const gl::Context *c
     const GLint layerTarget = index.cubeMapFaceIndex();
 
     ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT));
+    ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount));
 
     if ((0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS))
     {
-        if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::CUBE_FACE_COUNT))
+        if (0 <= layerTarget && layerTarget < static_cast<GLint>(gl::kCubeFaceCount))
         {
             // No need to let the old Image recover its data, if it is also the incoming Image.
             if (mAssociatedImages[layerTarget][level] != nullptr &&
@@ -2170,7 +2170,7 @@ angle::Result TextureStorage11_Cube::ensureTextureExists(const gl::Context *cont
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mipLevels;
-        desc.ArraySize          = gl::CUBE_FACE_COUNT;
+        desc.ArraySize          = gl::kCubeFaceCount;
         desc.Format             = mFormatInfo.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
@@ -2223,7 +2223,7 @@ angle::Result TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
     const int level     = index.getLevelIndex();
 
     ASSERT(level >= 0 && level < getLevelCount());
-    ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(gl::CUBE_FACE_COUNT));
+    ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(gl::kCubeFaceCount));
 
     Context11 *context11 = GetImplAs<Context11>(context);
 
@@ -2346,7 +2346,7 @@ angle::Result TextureStorage11_Cube::createSRVForSampler(const gl::Context *cont
         srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + baseLevel;
         srvDesc.Texture2DArray.MipLevels       = mipLevels;
         srvDesc.Texture2DArray.FirstArraySlice = 0;
-        srvDesc.Texture2DArray.ArraySize       = gl::CUBE_FACE_COUNT;
+        srvDesc.Texture2DArray.ArraySize       = gl::kCubeFaceCount;
     }
     else
     {
@@ -2398,7 +2398,7 @@ angle::Result TextureStorage11_Cube::createSRVForImage(const gl::Context *contex
     srvDesc.Texture2DArray.MostDetailedMip = mTopLevel + level;
     srvDesc.Texture2DArray.MipLevels       = 1;
     srvDesc.Texture2DArray.FirstArraySlice = 0;
-    srvDesc.Texture2DArray.ArraySize       = gl::CUBE_FACE_COUNT;
+    srvDesc.Texture2DArray.ArraySize       = gl::kCubeFaceCount;
     ANGLE_TRY(
         mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
     outSRV->setDebugName("TexStorageCube.SRVForImage");
@@ -2417,7 +2417,7 @@ angle::Result TextureStorage11_Cube::createUAVForImage(const gl::Context *contex
     uavDesc.ViewDimension                  = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
     uavDesc.Texture2DArray.MipSlice        = mTopLevel + level;
     uavDesc.Texture2DArray.FirstArraySlice = 0;
-    uavDesc.Texture2DArray.ArraySize       = gl::CUBE_FACE_COUNT;
+    uavDesc.Texture2DArray.ArraySize       = gl::kCubeFaceCount;
     ANGLE_TRY(
         mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV));
     outUAV->setDebugName("TexStorageCube.UAVForImage");
@@ -2437,7 +2437,7 @@ angle::Result TextureStorage11_Cube::getSwizzleTexture(const gl::Context *contex
         desc.Width              = mTextureWidth;
         desc.Height             = mTextureHeight;
         desc.MipLevels          = mMipLevels;
-        desc.ArraySize          = gl::CUBE_FACE_COUNT;
+        desc.ArraySize          = gl::kCubeFaceCount;
         desc.Format             = format.texFormat;
         desc.SampleDesc.Count   = 1;
         desc.SampleDesc.Quality = 0;
@@ -2473,7 +2473,7 @@ angle::Result TextureStorage11_Cube::getSwizzleRenderTarget(const gl::Context *c
         rtvDesc.ViewDimension                  = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
         rtvDesc.Texture2DArray.MipSlice        = mTopLevel + mipLevel;
         rtvDesc.Texture2DArray.FirstArraySlice = 0;
-        rtvDesc.Texture2DArray.ArraySize       = gl::CUBE_FACE_COUNT;
+        rtvDesc.Texture2DArray.ArraySize       = gl::kCubeFaceCount;
 
         ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
                                               mSwizzleTexture.get(),

src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h

@@ -36,7 +36,7 @@ class Image11;
 struct Renderer11DeviceCaps;
 
 template <typename T>
-using CubeFaceArray = std::array<T, gl::CUBE_FACE_COUNT>;
+using CubeFaceArray = std::array<T, gl::kCubeFaceCount>;
 
 class TextureStorage11 : public TextureStorage
 {

src/libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp

@@ -371,7 +371,7 @@ TextureStorage9_Cube::TextureStorage9_Cube(Renderer9 *renderer, GLenum internalf
     : TextureStorage9(renderer, GetTextureUsage(internalformat, renderTarget))
 {
     mTexture = nullptr;
-    for (size_t i = 0; i < gl::CUBE_FACE_COUNT; ++i)
+    for (size_t i = 0; i < gl::kCubeFaceCount; ++i)
     {
         mRenderTarget[i] = nullptr;
     }
@@ -392,7 +392,7 @@ TextureStorage9_Cube::~TextureStorage9_Cube()
 {
     SafeRelease(mTexture);
 
-    for (size_t i = 0; i < gl::CUBE_FACE_COUNT; ++i)
+    for (size_t i = 0; i < gl::kCubeFaceCount; ++i)
     {
         SafeDelete(mRenderTarget[i]);
     }

src/libANGLE/renderer/d3d/d3d9/TextureStorage9.h

@@ -146,7 +146,7 @@ class TextureStorage9_Cube : public TextureStorage9
 
   private:
     IDirect3DCubeTexture9 *mTexture;
-    RenderTarget9 *mRenderTarget[gl::CUBE_FACE_COUNT];
+    RenderTarget9 *mRenderTarget[gl::kCubeFaceCount];
 };
 
 }

src/libANGLE/renderer/gl/TextureGL.cpp

@@ -37,7 +37,7 @@ namespace
 size_t GetLevelInfoIndex(gl::TextureTarget target, size_t level)
 {
     return gl::IsCubeMapFaceTarget(target)
-               ? ((level * 6) + gl::CubeMapTextureTargetToFaceIndex(target))
+               ? ((level * gl::kCubeFaceCount) + gl::CubeMapTextureTargetToFaceIndex(target))
                : level;
 }
 
@@ -117,7 +117,7 @@ TextureGL::TextureGL(const gl::TextureState &state, GLuint id)
       mTextureID(id)
 {
     mLevelInfo.resize((gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS + 1) *
-                      (getType() == gl::TextureType::CubeMap ? 6 : 1));
+                      (getType() == gl::TextureType::CubeMap ? gl::kCubeFaceCount : 1));
 }
 
 TextureGL::~TextureGL()

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -135,7 +135,7 @@ uint32_t GetImageLayerCount(gl::TextureType textureType)
 {
     if (textureType == gl::TextureType::CubeMap)
     {
-        return gl::CUBE_FACE_COUNT;
+        return gl::kCubeFaceCount;
     }
     else
     {