Use IsCubeMapFaceTarget on texture targets

src/common/PackedEnums.cpp

@@ -42,6 +42,11 @@ TextureType TextureTargetToType(TextureTarget target)
     }
 }
 
+bool IsCubeMapFaceTarget(TextureTarget target)
+{
+    return TextureTargetToType(target) == TextureType::CubeMap;
+}
+
 TextureTarget NonCubeTextureTypeToTarget(TextureType type)
 {
     switch (type)
@@ -94,7 +99,7 @@ TextureTarget CubeFaceIndexToTextureTarget(size_t face)
 
 size_t CubeMapTextureTargetToFaceIndex(TextureTarget target)
 {
-    ASSERT(TextureTargetToType(target) == TextureType::CubeMap);
+    ASSERT(IsCubeMapFaceTarget(target));
     return static_cast<uint8_t>(target) - static_cast<uint8_t>(TextureTarget::CubeMapPositiveX);
 }
 

src/common/PackedEnums.h

@@ -142,6 +142,7 @@ TextureTarget NonCubeTextureTypeToTarget(TextureType type);
 
 TextureTarget CubeFaceIndexToTextureTarget(size_t face);
 size_t CubeMapTextureTargetToFaceIndex(TextureTarget target);
+bool IsCubeMapFaceTarget(TextureTarget target);
 
 constexpr TextureTarget kCubeMapTextureTargetMin = TextureTarget::CubeMapPositiveX;
 constexpr TextureTarget kCubeMapTextureTargetMax = TextureTarget::CubeMapNegativeZ;

src/libANGLE/ImageIndex.cpp

@@ -121,7 +121,7 @@ ImageIndex ImageIndex::MakeRectangle(GLint levelIndex)
 
 ImageIndex ImageIndex::MakeCube(TextureTarget target, GLint levelIndex)
 {
-    ASSERT(TextureTargetToType(target) == TextureType::CubeMap);
+    ASSERT(IsCubeMapFaceTarget(target));
     return ImageIndex(TextureType::CubeMap, levelIndex, TextureTargetToLayer(target), 1);
 }
 

src/libANGLE/Texture.cpp

@@ -33,9 +33,8 @@ bool IsPointSampled(const SamplerState &samplerState)
 
 size_t GetImageDescIndex(TextureTarget target, size_t level)
 {
-    return TextureTargetToType(target) == TextureType::CubeMap
-               ? (level * 6 + CubeMapTextureTargetToFaceIndex(target))
-               : level;
+    return IsCubeMapFaceTarget(target) ? (level * 6 + CubeMapTextureTargetToFaceIndex(target))
+                                       : level;
 }
 
 InitState DetermineInitState(const Context *context, const uint8_t *pixels)

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -1589,7 +1589,7 @@ ImageD3D *TextureD3D_Cube::getImage(int level, int layer) const
 ImageD3D *TextureD3D_Cube::getImage(const gl::ImageIndex &index) const
 {
     ASSERT(index.getLevelIndex() < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap);
+    ASSERT(gl::IsCubeMapFaceTarget(index.getTarget()));
     return mImageArray[index.cubeMapFaceIndex()][index.getLevelIndex()].get();
 }
 
@@ -1803,7 +1803,7 @@ gl::Error TextureD3D_Cube::copyTexture(const gl::Context *context,
                                        bool unpackUnmultiplyAlpha,
                                        const gl::Texture *source)
 {
-    ASSERT(gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap);
+    ASSERT(gl::IsCubeMapFaceTarget(index.getTarget()));
 
     gl::TextureTarget sourceTarget = NonCubeTextureTypeToTarget(source->getType());
 
@@ -1861,7 +1861,7 @@ gl::Error TextureD3D_Cube::copySubTexture(const gl::Context *context,
                                           bool unpackUnmultiplyAlpha,
                                           const gl::Texture *source)
 {
-    ASSERT(gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap);
+    ASSERT(gl::IsCubeMapFaceTarget(index.getTarget()));
 
     GLint faceIndex = index.cubeMapFaceIndex();
 
@@ -2008,7 +2008,7 @@ gl::Error TextureD3D_Cube::getRenderTarget(const gl::Context *context,
                                            const gl::ImageIndex &index,
                                            RenderTargetD3D **outRT)
 {
-    ASSERT(gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap);
+    ASSERT(gl::IsCubeMapFaceTarget(index.getTarget()));
 
     // ensure the underlying texture is created
     ANGLE_TRY(ensureRenderTarget(context));
@@ -2245,8 +2245,8 @@ gl::ImageIndex TextureD3D_Cube::getImageIndex(GLint mip, GLint layer) const
 bool TextureD3D_Cube::isValidIndex(const gl::ImageIndex &index) const
 {
     return (mTexStorage && index.getType() == gl::TextureType::CubeMap &&
-            gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap &&
-            index.getLevelIndex() >= 0 && index.getLevelIndex() < mTexStorage->getLevelCount());
+            gl::IsCubeMapFaceTarget(index.getTarget()) && index.getLevelIndex() >= 0 &&
+            index.getLevelIndex() < mTexStorage->getLevelCount());
 }
 
 void TextureD3D_Cube::markAllImagesDirty()

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

@@ -521,7 +521,7 @@ gl::Error TextureStorage9_Cube::getRenderTarget(const gl::Context *context,
     ASSERT(index.getLevelIndex() == 0);
 
     ASSERT(index.getType() == gl::TextureType::CubeMap &&
-           gl::TextureTargetToType(index.getTarget()) == gl::TextureType::CubeMap);
+           gl::IsCubeMapFaceTarget(index.getTarget()));
     const size_t renderTargetIndex = index.cubeMapFaceIndex();
 
     if (mRenderTarget[renderTargetIndex] == nullptr && isRenderTarget())

src/libANGLE/renderer/gl/TextureGL.cpp

@@ -35,7 +35,7 @@ namespace
 
 size_t GetLevelInfoIndex(gl::TextureTarget target, size_t level)
 {
-    return gl::TextureTargetToType(target) == gl::TextureType::CubeMap
+    return gl::IsCubeMapFaceTarget(target)
                ? ((level * 6) + gl::CubeMapTextureTargetToFaceIndex(target))
                : level;
 }