GL: Support GL_OES_texture_cube_map_array in frontend/GL backend

scripts/code_generation_hashes/packed_enum.json

@@ -4,13 +4,13 @@
   "src/common/PackedEGLEnums_autogen.h":
     "085d82d2003f02345abc4986523127d4",
   "src/common/PackedGLEnums_autogen.cpp":
-    "8fceeabaa8a96d0f0b2034e2c56ff597",
+    "dfd979452806f59fff27dde8ffe8e300",
   "src/common/PackedGLEnums_autogen.h":
-    "9baa6356c86dfbf72380539698b55590",
+    "8466493b646665844ac579e997ebb6ca",
   "src/common/gen_packed_gl_enums.py":
     "b3e96ea44f52ec23ee893bd843dfd2cb",
   "src/common/packed_egl_enums.json":
     "76e1b814421e121164d60a0d89cb16c1",
   "src/common/packed_gl_enums.json":
-    "fbe589dc6c790f0df47e30a4bf0a48ea"
+    "5ed701940bc80450631f8886d585ef8a"
 }
\ No newline at end of file

src/common/PackedEnums.cpp

@@ -24,6 +24,8 @@ TextureType TextureTargetToType(TextureTarget target)
         case TextureTarget::CubeMapPositiveY:
         case TextureTarget::CubeMapPositiveZ:
             return TextureType::CubeMap;
+        case TextureTarget::CubeMapArray:
+            return TextureType::CubeMapArray;
         case TextureTarget::External:
             return TextureType::External;
         case TextureTarget::Rectangle:
@@ -71,6 +73,8 @@ TextureTarget NonCubeTextureTypeToTarget(TextureType type)
             return TextureTarget::_2DMultisampleArray;
         case TextureType::_3D:
             return TextureTarget::_3D;
+        case TextureType::CubeMapArray:
+            return TextureTarget::CubeMapArray;
         case TextureType::VideoImage:
             return TextureTarget::VideoImage;
         default:
@@ -132,6 +136,12 @@ TextureType SamplerTypeToTextureType(GLenum samplerType)
         case GL_SAMPLER_CUBE_SHADOW:
             return TextureType::CubeMap;
 
+        case GL_SAMPLER_CUBE_MAP_ARRAY:
+        case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
+        case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
+        case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
+            return TextureType::CubeMapArray;
+
         case GL_SAMPLER_2D_ARRAY:
         case GL_INT_SAMPLER_2D_ARRAY:
         case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
@@ -183,6 +193,7 @@ bool IsArrayTextureType(TextureType type)
     {
         case TextureType::_2DArray:
         case TextureType::_2DMultisampleArray:
+        case TextureType::CubeMapArray:
             return true;
         default:
             return false;

src/common/PackedGLEnums_autogen.cpp

@@ -1993,6 +1993,8 @@ TextureTarget FromGLenum<TextureTarget>(GLenum from)
             return TextureTarget::CubeMapPositiveZ;
         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
             return TextureTarget::CubeMapNegativeZ;
+        case GL_TEXTURE_CUBE_MAP_ARRAY:
+            return TextureTarget::CubeMapArray;
         case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
             return TextureTarget::VideoImage;
         default:
@@ -2030,6 +2032,8 @@ GLenum ToGLenum(TextureTarget from)
             return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
         case TextureTarget::CubeMapNegativeZ:
             return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+        case TextureTarget::CubeMapArray:
+            return GL_TEXTURE_CUBE_MAP_ARRAY;
         case TextureTarget::VideoImage:
             return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
         default:
@@ -2081,6 +2085,9 @@ std::ostream &operator<<(std::ostream &os, TextureTarget value)
         case TextureTarget::CubeMapNegativeZ:
             os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z";
             break;
+        case TextureTarget::CubeMapArray:
+            os << "GL_TEXTURE_CUBE_MAP_ARRAY";
+            break;
         case TextureTarget::VideoImage:
             os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
             break;
@@ -2112,6 +2119,8 @@ TextureType FromGLenum<TextureType>(GLenum from)
             return TextureType::Rectangle;
         case GL_TEXTURE_CUBE_MAP:
             return TextureType::CubeMap;
+        case GL_TEXTURE_CUBE_MAP_ARRAY:
+            return TextureType::CubeMapArray;
         case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
             return TextureType::VideoImage;
         default:
@@ -2139,6 +2148,8 @@ GLenum ToGLenum(TextureType from)
             return GL_TEXTURE_RECTANGLE_ANGLE;
         case TextureType::CubeMap:
             return GL_TEXTURE_CUBE_MAP;
+        case TextureType::CubeMapArray:
+            return GL_TEXTURE_CUBE_MAP_ARRAY;
         case TextureType::VideoImage:
             return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
         default:
@@ -2175,6 +2186,9 @@ std::ostream &operator<<(std::ostream &os, TextureType value)
         case TextureType::CubeMap:
             os << "GL_TEXTURE_CUBE_MAP";
             break;
+        case TextureType::CubeMapArray:
+            os << "GL_TEXTURE_CUBE_MAP_ARRAY";
+            break;
         case TextureType::VideoImage:
             os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
             break;

src/common/PackedGLEnums_autogen.h

@@ -515,10 +515,11 @@ enum class TextureTarget : uint8_t
     CubeMapNegativeY    = 10,
     CubeMapPositiveZ    = 11,
     CubeMapNegativeZ    = 12,
-    VideoImage          = 13,
+    CubeMapArray        = 13,
+    VideoImage          = 14,
 
-    InvalidEnum = 14,
-    EnumCount   = 14,
+    InvalidEnum = 15,
+    EnumCount   = 15,
 };
 
 template <>
@@ -536,10 +537,11 @@ enum class TextureType : uint8_t
     External            = 5,
     Rectangle           = 6,
     CubeMap             = 7,
-    VideoImage          = 8,
+    CubeMapArray        = 8,
+    VideoImage          = 9,
 
-    InvalidEnum = 9,
-    EnumCount   = 9,
+    InvalidEnum = 10,
+    EnumCount   = 10,
 };
 
 template <>

src/common/packed_gl_enums.json

@@ -188,6 +188,7 @@
         "External": "GL_TEXTURE_EXTERNAL_OES",
         "Rectangle": "GL_TEXTURE_RECTANGLE_ANGLE",
         "CubeMap": "GL_TEXTURE_CUBE_MAP",
+        "CubeMapArray": "GL_TEXTURE_CUBE_MAP_ARRAY",
         "VideoImage": "GL_TEXTURE_VIDEO_IMAGE_WEBGL"
     },
     "TextureTarget":
@@ -205,6 +206,7 @@
         "CubeMapNegativeY": "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y",
         "CubeMapPositiveZ": "GL_TEXTURE_CUBE_MAP_POSITIVE_Z",
         "CubeMapNegativeZ": "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z",
+        "CubeMapArray": "GL_TEXTURE_CUBE_MAP_ARRAY",
         "VideoImage": "GL_TEXTURE_VIDEO_IMAGE_WEBGL"
     },
     "VertexArrayType":

src/libANGLE/Caps.cpp

@@ -1023,6 +1023,8 @@ const ExtensionInfoMap &GetExtensionInfoMap()
         map["GL_ANGLE_memory_size"] = enableableExtension(&Extensions::memorySize);
         map["GL_EXT_shader_non_constant_global_initializers"] = enableableExtension(&Extensions::shaderNonConstGlobalInitializersEXT);
         map["GL_WEBGL_video_texture"] = enableableExtension(&Extensions::webglVideoTexture);
+        map["GL_OES_texture_cube_map_array"] = enableableExtension(&Extensions::textureCubeMapArrayOES);
+        map["GL_EXT_texture_cube_map_array"] = enableableExtension(&Extensions::textureCubeMapArrayEXT);
         // clang-format on
 
 #if defined(ANGLE_ENABLE_ASSERTS)

src/libANGLE/Caps.h

@@ -623,6 +623,16 @@ struct Extensions
 
     // GL_APPLE_clip_distance
     bool clipDistanceAPPLE = false;
+
+    // GL_OES_texture_cube_map_array
+    bool textureCubeMapArrayOES = false;
+    // GL_EXT_texture_cube_map_array
+    bool textureCubeMapArrayEXT = false;
+    // Any version of the texture cube map array extension
+    bool textureCubeMapArrayAny() const
+    {
+        return (textureCubeMapArrayOES || textureCubeMapArrayEXT);
+    }
 };
 
 // Pointer to a boolean memeber of the Extensions struct

src/libANGLE/Context.cpp

@@ -378,6 +378,13 @@ void Context::initialize()
         }
     }
 
+    if (getClientVersion() >= Version(3, 2) || mSupportedExtensions.textureCubeMapArrayAny())
+    {
+        Texture *zeroTextureCubeMapArray =
+            new Texture(mImplementation.get(), {0}, TextureType::CubeMapArray);
+        mZeroTextures[TextureType::CubeMapArray].set(this, zeroTextureCubeMapArray);
+    }
+
     if (mSupportedExtensions.textureRectangle)
     {
         Texture *zeroTextureRectangle =
@@ -8806,6 +8813,7 @@ void StateCache::updateValidBindTextureTypes(Context *context)
         {TextureType::External, exts.eglImageExternalOES || exts.eglStreamConsumerExternalNV},
         {TextureType::Rectangle, exts.textureRectangle},
         {TextureType::CubeMap, true},
+        {TextureType::CubeMapArray, exts.textureCubeMapArrayAny()},
         {TextureType::VideoImage, exts.webglVideoTexture},
     }};
 }

src/libANGLE/ErrorStrings.h

@@ -73,6 +73,7 @@ MSG kContextLost = "Context has been lost.";
 MSG kCopyAlias = "The read and write copy regions alias memory.";
 MSG kCubemapFacesEqualDimensions = "Each cubemap face must have equal width and height.";
 MSG kCubemapIncomplete = "Texture is not cubemap complete. All cubemaps faces must be defined and be the same size.";
+MSG kCubemapInvalidDepth = "The cubemap depth must be a multiple of 6.";
 MSG kDataTypeNotAligned = "Data is not evenly divisible into the number of bytes needed to store in memory a datum indicated by type.";
 MSG kDefaultFramebuffer = "Default framebuffer is bound.";
 MSG kDefaultFramebufferInvalidAttachment = "Invalid attachment when the default framebuffer is bound.";

src/libANGLE/ImageIndex.cpp

@@ -50,6 +50,8 @@ GLint TextureTargetToLayer(TextureTarget target)
             return ImageIndex::kEntireLevel;
         case TextureTarget::_3D:
             return ImageIndex::kEntireLevel;
+        case TextureTarget::CubeMapArray:
+            return ImageIndex::kEntireLevel;
         default:
             UNREACHABLE();
             return 0;
@@ -105,6 +107,7 @@ bool ImageIndex::isLayered() const
         case TextureType::_2DMultisampleArray:
         case TextureType::CubeMap:
         case TextureType::_3D:
+        case TextureType::CubeMapArray:
             return mLayerIndex == kEntireLevel;
         default:
             return false;
@@ -122,7 +125,7 @@ bool ImageIndex::has3DLayer() const
 bool ImageIndex::usesTex3D() const
 {
     return mType == TextureType::_3D || mType == TextureType::_2DArray ||
-           mType == TextureType::_2DMultisampleArray;
+           mType == TextureType::_2DMultisampleArray || mType == TextureType::CubeMapArray;
 }
 
 TextureTarget ImageIndex::getTarget() const

src/libANGLE/State.cpp

@@ -467,6 +467,10 @@ void State::initialize(Context *context)
         mShaderStorageBuffers.resize(caps.maxShaderStorageBufferBindings);
         mImageUnits.resize(caps.maxImageUnits);
     }
+    if (extensions.textureCubeMapArrayAny())
+    {
+        mSamplerTextures[TextureType::CubeMapArray].resize(caps.maxCombinedTextureImageUnits);
+    }
     if (nativeExtensions.textureRectangle)
     {
         mSamplerTextures[TextureType::Rectangle].resize(caps.maxCombinedTextureImageUnits);
@@ -2688,6 +2692,12 @@ angle::Result State::getIntegerv(const Context *context, GLenum pname, GLint *pa
                                           TextureType::_2DMultisampleArray)
                           .value;
             break;
+        case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
+            ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
+            *params = getSamplerTextureId(static_cast<unsigned int>(mActiveSampler),
+                                          TextureType::CubeMapArray)
+                          .value;
+            break;
         case GL_TEXTURE_BINDING_EXTERNAL_OES:
             ASSERT(mActiveSampler < mMaxCombinedTextureImageUnits);
             *params = getSamplerTextureId(static_cast<unsigned int>(mActiveSampler),

src/libANGLE/Texture.cpp

@@ -485,7 +485,7 @@ bool TextureState::computeLevelCompleteness(TextureTarget target, size_t level)
             return false;
         }
     }
-    else if (mType == TextureType::_2DArray)
+    else if (IsArrayTextureType(mType))
     {
         if (levelImageDesc.size.depth != baseImageDesc.size.depth)
         {
@@ -600,7 +600,7 @@ void TextureState::setImageDescChain(GLuint baseLevel,
         int relativeLevel = (level - baseLevel);
         Extents levelSize(std::max<int>(baseSize.width >> relativeLevel, 1),
                           std::max<int>(baseSize.height >> relativeLevel, 1),
-                          (mType == TextureType::_2DArray)
+                          (IsArrayTextureType(mType))
                               ? baseSize.depth
                               : std::max<int>(baseSize.depth >> relativeLevel, 1));
         ImageDesc levelInfo(levelSize, format, initState);

src/libANGLE/queryutils.cpp

@@ -3602,6 +3602,17 @@ bool GetQueryParameterInfo(const State &glState,
         }
     }
 
+    if (extensions.textureCubeMapArrayAny())
+    {
+        switch (pname)
+        {
+            case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
+                *type      = GL_INT;
+                *numParams = 1;
+                return true;
+        }
+    }
+
     if (glState.getClientVersion() < Version(3, 1))
     {
         return false;

src/libANGLE/renderer/gl/FramebufferGL.cpp

@@ -97,7 +97,8 @@ void BindFramebufferAttachment(const FunctionsGL *functions,
                 TextureType textureType = texture->getType();
                 ASSERT(textureType == TextureType::_2DArray || textureType == TextureType::_3D ||
                        textureType == TextureType::CubeMap ||
-                       textureType == TextureType::_2DMultisampleArray);
+                       textureType == TextureType::_2DMultisampleArray ||
+                       textureType == TextureType::CubeMapArray);
                 functions->framebufferTexture(GL_FRAMEBUFFER, attachmentPoint,
                                               textureGL->getTextureID(), attachment->mipLevel());
             }
@@ -109,7 +110,8 @@ void BindFramebufferAttachment(const FunctionsGL *functions,
             }
             else if (texture->getType() == TextureType::_2DArray ||
                      texture->getType() == TextureType::_3D ||
-                     texture->getType() == TextureType::_2DMultisampleArray)
+                     texture->getType() == TextureType::_2DMultisampleArray ||
+                     texture->getType() == TextureType::CubeMapArray)
             {
                 if (attachment->isMultiview())
                 {

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1816,7 +1816,8 @@ bool UseTexImage2D(gl::TextureType textureType)
 bool UseTexImage3D(gl::TextureType textureType)
 {
     return textureType == gl::TextureType::_2DArray || textureType == gl::TextureType::_3D ||
-           textureType == gl::TextureType::_2DMultisampleArray;
+           textureType == gl::TextureType::_2DMultisampleArray ||
+           textureType == gl::TextureType::CubeMapArray;
 }
 
 GLenum GetTextureBindingQuery(gl::TextureType textureType)
@@ -1839,6 +1840,8 @@ GLenum GetTextureBindingQuery(gl::TextureType textureType)
             return GL_TEXTURE_BINDING_RECTANGLE;
         case gl::TextureType::CubeMap:
             return GL_TEXTURE_BINDING_CUBE_MAP;
+        case gl::TextureType::CubeMapArray:
+            return GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES;
         default:
             UNREACHABLE();
             return 0;

src/libANGLE/validationES.cpp

@@ -569,6 +569,10 @@ bool ValidTextureTarget(const Context *context, TextureType type)
         case TextureType::_2DMultisampleArray:
             return context->getExtensions().textureStorageMultisample2DArrayOES;
 
+        case TextureType::CubeMapArray:
+            return (context->getClientVersion() >= Version(3, 2) ||
+                    context->getExtensions().textureCubeMapArrayAny());
+
         case TextureType::VideoImage:
             return context->getExtensions().webglVideoTexture;
 
@@ -601,6 +605,10 @@ bool ValidTexture3DTarget(const Context *context, TextureType target)
         case TextureType::_2DArray:
             return (context->getClientMajorVersion() >= 3);
 
+        case TextureType::CubeMapArray:
+            return (context->getClientVersion() >= Version(3, 2) ||
+                    context->getExtensions().textureCubeMapArrayAny());
+
         default:
             return false;
     }
@@ -782,6 +790,7 @@ bool ValidTexture3DDestinationTarget(const Context *context, TextureTarget targe
     {
         case TextureTarget::_3D:
         case TextureTarget::_2DArray:
+        case TextureTarget::CubeMapArray:
             return true;
         default:
             return false;
@@ -798,6 +807,9 @@ bool ValidTexLevelDestinationTarget(const Context *context, TextureType type)
         case TextureType::CubeMap:
         case TextureType::_3D:
             return true;
+        case TextureType::CubeMapArray:
+            return (context->getClientVersion() >= Version(3, 2) ||
+                    context->getExtensions().textureCubeMapArrayAny());
         case TextureType::Rectangle:
             return context->getExtensions().textureRectangle;
         case TextureType::_2DMultisampleArray:
@@ -844,6 +856,7 @@ bool ValidMipLevel(const Context *context, TextureType type, GLint level)
             break;
 
         case TextureType::CubeMap:
+        case TextureType::CubeMapArray:
             maxDimension = caps.maxCubeMapTextureSize;
             break;
 
@@ -2629,6 +2642,7 @@ bool ValidateCopyTexImageParametersBase(const Context *context,
             break;
 
         case TextureType::CubeMap:
+        case TextureType::CubeMapArray:
             maxDimension = caps.maxCubeMapTextureSize;
             break;
 
@@ -2684,7 +2698,8 @@ bool ValidateCopyTexImageParametersBase(const Context *context,
     }
     else
     {
-        if (texType == TextureType::CubeMap && width != height)
+        if ((texType == TextureType::CubeMap || texType == TextureType::CubeMapArray) &&
+            width != height)
         {
             context->validationError(GL_INVALID_VALUE, kCubemapIncomplete);
             return false;

src/libANGLE/validationES3.cpp

@@ -492,6 +492,34 @@ bool ValidateES3TexImageParametersBase(const Context *context,
             }
             break;
 
+        case TextureType::CubeMapArray:
+            if (!isSubImage && width != height)
+            {
+                context->validationError(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
+                return false;
+            }
+
+            if (width > (caps.maxCubeMapTextureSize >> level))
+            {
+                context->validationError(GL_INVALID_VALUE, kResourceMaxTextureSize);
+                return false;
+            }
+
+            if (width > (caps.max3DTextureSize >> level) ||
+                height > (caps.max3DTextureSize >> level) ||
+                depth > (caps.max3DTextureSize >> level))
+            {
+                context->validationError(GL_INVALID_VALUE, kResourceMaxTextureSize);
+                return false;
+            }
+
+            if (!isSubImage && depth % 6 != 0)
+            {
+                context->validationError(GL_INVALID_VALUE, kCubemapInvalidDepth);
+                return false;
+            }
+            break;
+
         default:
             context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
             return false;
@@ -1207,6 +1235,35 @@ bool ValidateES3TexStorageParametersBase(const Context *context,
         }
         break;
 
+        case TextureType::CubeMapArray:
+        {
+            if (width != height)
+            {
+                context->validationError(GL_INVALID_VALUE, kCubemapFacesEqualDimensions);
+                return false;
+            }
+
+            if (width > caps.maxCubeMapTextureSize)
+            {
+                context->validationError(GL_INVALID_VALUE, kResourceMaxTextureSize);
+                return false;
+            }
+
+            if (width > caps.max3DTextureSize || height > caps.max3DTextureSize ||
+                depth > caps.max3DTextureSize)
+            {
+                context->validationError(GL_INVALID_VALUE, kResourceMaxTextureSize);
+                return false;
+            }
+
+            if (depth % 6 != 0)
+            {
+                context->validationError(GL_INVALID_VALUE, kCubemapInvalidDepth);
+                return false;
+            }
+        }
+        break;
+
         default:
             UNREACHABLE();
             return false;
@@ -1419,6 +1476,22 @@ bool ValidateFramebufferTextureLayer(const Context *context,
             }
             break;
 
+            case TextureType::CubeMapArray:
+            {
+                if (level > log2(caps.max3DTextureSize))
+                {
+                    context->validationError(GL_INVALID_VALUE, kFramebufferTextureInvalidMipLevel);
+                    return false;
+                }
+
+                if (layer >= caps.max3DTextureSize)
+                {
+                    context->validationError(GL_INVALID_VALUE, kFramebufferTextureInvalidLayer);
+                    return false;
+                }
+            }
+            break;
+
             default:
                 context->validationError(GL_INVALID_OPERATION,
                                          kFramebufferTextureLayerIncorrectTextureType);