Merge all gl::Texture* classes.

src/common/utilities.cpp

@@ -343,9 +343,27 @@ int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsig
     return -1;
 }
 
-bool IsCubemapTextureTarget(GLenum target)
+META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 1);
+META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 2);
+META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 3);
+META_ASSERT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 4);
+META_ASSERT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z - GL_TEXTURE_CUBE_MAP_POSITIVE_X == 5);
+
+bool IsCubeMapTextureTarget(GLenum target)
+{
+    return (target >= FirstCubeMapTextureTarget && target <= LastCubeMapTextureTarget);
+}
+
+size_t CubeMapTextureTargetToLayerIndex(GLenum target)
+{
+    ASSERT(IsCubeMapTextureTarget(target));
+    return target - static_cast<size_t>(FirstCubeMapTextureTarget);
+}
+
+GLenum LayerIndexToCubeMapTextureTarget(size_t index)
 {
-    return (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
+    ASSERT(index <= (LastCubeMapTextureTarget - FirstCubeMapTextureTarget));
+    return FirstCubeMapTextureTarget + static_cast<GLenum>(index);
 }
 
 bool IsTriangleMode(GLenum drawMode)

src/common/utilities.h

@@ -34,7 +34,11 @@ int VariableSortOrder(GLenum type);
 
 int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize);
 
-bool IsCubemapTextureTarget(GLenum target);
+static const GLenum FirstCubeMapTextureTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
+static const GLenum LastCubeMapTextureTarget = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
+bool IsCubeMapTextureTarget(GLenum target);
+size_t CubeMapTextureTargetToLayerIndex(GLenum target);
+GLenum LayerIndexToCubeMapTextureTarget(size_t index);
 
 bool IsTriangleMode(GLenum drawMode);
 

src/libANGLE/Context.cpp

@@ -64,19 +64,19 @@ Context::Context(int clientVersion, const Context *shareContext, rx::Renderer *r
     // In order that access to these initial textures not be lost, they are treated as texture
     // objects all of whose names are 0.
 
-    Texture2D *zeroTexture2D = new Texture2D(mRenderer->createTexture(GL_TEXTURE_2D), 0);
+    Texture *zeroTexture2D = new Texture(mRenderer->createTexture(GL_TEXTURE_2D), 0, GL_TEXTURE_2D);
     mZeroTextures[GL_TEXTURE_2D].set(zeroTexture2D);
 
-    TextureCubeMap *zeroTextureCube = new TextureCubeMap(mRenderer->createTexture(GL_TEXTURE_CUBE_MAP), 0);
+    Texture *zeroTextureCube = new Texture(mRenderer->createTexture(GL_TEXTURE_CUBE_MAP), 0, GL_TEXTURE_CUBE_MAP);
     mZeroTextures[GL_TEXTURE_CUBE_MAP].set(zeroTextureCube);
 
     if (mClientVersion >= 3)
     {
         // TODO: These could also be enabled via extension
-        Texture3D *zeroTexture3D = new Texture3D(mRenderer->createTexture(GL_TEXTURE_3D), 0);
+        Texture *zeroTexture3D = new Texture(mRenderer->createTexture(GL_TEXTURE_3D), 0, GL_TEXTURE_3D);
         mZeroTextures[GL_TEXTURE_3D].set(zeroTexture3D);
 
-        Texture2DArray *zeroTexture2DArray = new Texture2DArray(mRenderer->createTexture(GL_TEXTURE_2D_ARRAY), 0);
+        Texture *zeroTexture2DArray = new Texture(mRenderer->createTexture(GL_TEXTURE_2D_ARRAY), 0, GL_TEXTURE_2D_ARRAY);
         mZeroTextures[GL_TEXTURE_2D_ARRAY].set(zeroTexture2DArray);
     }
 
@@ -724,39 +724,9 @@ Query *Context::getQuery(unsigned int handle, bool create, GLenum type)
 
 Texture *Context::getTargetTexture(GLenum target) const
 {
-    if (!ValidTextureTarget(this, target))
-    {
-        return NULL;
-    }
-
-    switch (target)
-    {
-      case GL_TEXTURE_2D:       return getTexture2D();
-      case GL_TEXTURE_CUBE_MAP: return getTextureCubeMap();
-      case GL_TEXTURE_3D:       return getTexture3D();
-      case GL_TEXTURE_2D_ARRAY: return getTexture2DArray();
-      default:                  return NULL;
-    }
-}
-
-Texture2D *Context::getTexture2D() const
-{
-    return static_cast<Texture2D*>(getSamplerTexture(mState.getActiveSampler(), GL_TEXTURE_2D));
-}
-
-TextureCubeMap *Context::getTextureCubeMap() const
-{
-    return static_cast<TextureCubeMap*>(getSamplerTexture(mState.getActiveSampler(), GL_TEXTURE_CUBE_MAP));
-}
+    ASSERT(ValidTextureTarget(this, target));
 
-Texture3D *Context::getTexture3D() const
-{
-    return static_cast<Texture3D*>(getSamplerTexture(mState.getActiveSampler(), GL_TEXTURE_3D));
-}
-
-Texture2DArray *Context::getTexture2DArray() const
-{
-    return static_cast<Texture2DArray*>(getSamplerTexture(mState.getActiveSampler(), GL_TEXTURE_2D_ARRAY));
+    return getSamplerTexture(mState.getActiveSampler(), target);
 }
 
 Texture *Context::getSamplerTexture(unsigned int sampler, GLenum type) const

src/libANGLE/Context.h

@@ -42,10 +42,6 @@ class Compiler;
 class Shader;
 class Program;
 class Texture;
-class Texture2D;
-class TextureCubeMap;
-class Texture3D;
-class Texture2DArray;
 class Framebuffer;
 class Renderbuffer;
 class FenceNV;
@@ -151,11 +147,6 @@ class Context
     TransformFeedback *getTransformFeedback(GLuint handle) const;
 
     Texture *getTargetTexture(GLenum target) const;
-    Texture2D *getTexture2D() const;
-    TextureCubeMap *getTextureCubeMap() const;
-    Texture3D *getTexture3D() const;
-    Texture2DArray *getTexture2DArray() const;
-
     Texture *getSamplerTexture(unsigned int sampler, GLenum type) const;
 
     Compiler *getCompiler() const;

src/libANGLE/FramebufferAttachment.cpp

@@ -123,7 +123,7 @@ GLint TextureAttachment::mipLevel() const
 
 GLenum TextureAttachment::cubeMapFace() const
 {
-    return IsCubemapTextureTarget(mIndex.type) ? mIndex.type : GL_NONE;
+    return IsCubeMapTextureTarget(mIndex.type) ? mIndex.type : GL_NONE;
 }
 
 GLint TextureAttachment::layer() const

src/libANGLE/ImageIndex.cpp

@@ -7,7 +7,7 @@
 // ImageIndex.cpp: Implementation for ImageIndex methods.
 
 #include "libANGLE/ImageIndex.h"
-#include "libANGLE/Texture.h"
+#include "libANGLE/Constants.h"
 #include "common/utilities.h"
 
 namespace gl
@@ -34,8 +34,8 @@ ImageIndex ImageIndex::Make2D(GLint mipIndex)
 
 ImageIndex ImageIndex::MakeCube(GLenum target, GLint mipIndex)
 {
-    ASSERT(gl::IsCubemapTextureTarget(target));
-    return ImageIndex(target, mipIndex, TextureCubeMap::targetToLayerIndex(target));
+    ASSERT(gl::IsCubeMapTextureTarget(target));
+    return ImageIndex(target, mipIndex, CubeMapTextureTargetToLayerIndex(target));
 }
 
 ImageIndex ImageIndex::Make2DArray(GLint mipIndex, GLint layerIndex)
@@ -134,7 +134,7 @@ ImageIndex ImageIndexIterator::current() const
 
     if (mType == GL_TEXTURE_CUBE_MAP)
     {
-        value.type = TextureCubeMap::layerIndexToTarget(mCurrentLayer);
+        value.type = LayerIndexToCubeMapTextureTarget(mCurrentLayer);
     }
 
     return value;

src/libANGLE/ResourceManager.cpp

@@ -370,30 +370,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, GLenum type)
 {
     if (!getTexture(texture) && texture != 0)
     {
-        Texture *textureObject;
-
-        if (type == GL_TEXTURE_2D)
-        {
-            textureObject = new Texture2D(mRenderer->createTexture(GL_TEXTURE_2D), texture);
-        }
-        else if (type == GL_TEXTURE_CUBE_MAP)
-        {
-            textureObject = new TextureCubeMap(mRenderer->createTexture(GL_TEXTURE_CUBE_MAP), texture);
-        }
-        else if (type == GL_TEXTURE_3D)
-        {
-            textureObject = new Texture3D(mRenderer->createTexture(GL_TEXTURE_3D), texture);
-        }
-        else if (type == GL_TEXTURE_2D_ARRAY)
-        {
-            textureObject = new Texture2DArray(mRenderer->createTexture(GL_TEXTURE_2D_ARRAY), texture);
-        }
-        else
-        {
-            UNREACHABLE();
-            return;
-        }
-
+        Texture *textureObject = new Texture(mRenderer->createTexture(type), texture, type);
         mTextureMap[texture] = textureObject;
         textureObject->addRef();
     }

src/libANGLE/Texture.h

@@ -4,9 +4,7 @@
 // found in the LICENSE file.
 //
 
-// Texture.h: Defines the abstract gl::Texture class and its concrete derived
-// classes Texture2D and TextureCubeMap. Implements GL texture objects and
-// related functionality. [OpenGL ES 2.0.24] section 3.7 page 63.
+// Texture.h: Defines the gl::Texture class [OpenGL ES 2.0.24] section 3.7 page 63.
 
 #ifndef LIBANGLE_TEXTURE_H_
 #define LIBANGLE_TEXTURE_H_
@@ -35,7 +33,7 @@ struct Data;
 
 bool IsMipmapFiltered(const gl::SamplerState &samplerState);
 
-class Texture : public RefCountObject
+class Texture final : public RefCountObject
 {
   public:
     Texture(rx::TextureImpl *impl, GLuint id, GLenum target);
@@ -55,7 +53,8 @@ class Texture : public RefCountObject
     size_t getDepth(GLenum target, size_t level) const;
     GLenum getInternalFormat(GLenum target, size_t level) const;
 
-    virtual bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const = 0;
+    bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const;
+    bool isCubeComplete() const;
 
     virtual Error setImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size, GLenum format, GLenum type,
                            const PixelUnpackState &unpack, const uint8_t *pixels);
@@ -91,7 +90,9 @@ class Texture : public RefCountObject
 
     static const GLuint INCOMPLETE_TEXTURE_ID = static_cast<GLuint>(-1);   // Every texture takes an id at creation time. The value is arbitrary because it is never registered with the resource manager.
 
-  protected:
+  private:
+    DISALLOW_COPY_AND_ASSIGN(Texture);
+
     static unsigned int issueTextureSerial();
 
     rx::TextureImpl *mTexture;
@@ -126,8 +127,11 @@ class Texture : public RefCountObject
     const unsigned int mTextureSerial;
     static unsigned int mCurrentTextureSerial;
 
-  private:
-    DISALLOW_COPY_AND_ASSIGN(Texture);
+    GLenum getBaseImageTarget() const;
+    size_t getExpectedMipLevels() const;
+
+    bool isMipmapComplete() const;
+    bool isLevelComplete(GLenum target, size_t level) const;
 
     const ImageDesc &getImageDesc(const ImageIdentifier& index) const;
     void setImageDesc(const ImageIdentifier& index, const ImageDesc &desc);
@@ -140,75 +144,6 @@ class Texture : public RefCountObject
     egl::Surface *mBoundSurface;
 };
 
-class Texture2D : public Texture
-{
-  public:
-    Texture2D(rx::TextureImpl *impl, GLuint id);
-
-    virtual ~Texture2D();
-
-    virtual bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(Texture2D);
-
-    bool isMipmapComplete() const;
-    bool isLevelComplete(size_t level) const;
-};
-
-class TextureCubeMap : public Texture
-{
-  public:
-    TextureCubeMap(rx::TextureImpl *impl, GLuint id);
-
-    virtual ~TextureCubeMap();
-
-    virtual bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const;
-
-    bool isCubeComplete() const;
-
-    static int targetToLayerIndex(GLenum target);
-    static GLenum layerIndexToTarget(GLint layer);
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(TextureCubeMap);
-
-    bool isMipmapComplete() const;
-    bool isFaceLevelComplete(GLenum target, size_t level) const;
-};
-
-class Texture3D : public Texture
-{
-  public:
-    Texture3D(rx::TextureImpl *impl, GLuint id);
-
-    virtual ~Texture3D();
-
-    virtual bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(Texture3D);
-
-    bool isMipmapComplete() const;
-    bool isLevelComplete(size_t level) const;
-};
-
-class Texture2DArray : public Texture
-{
-  public:
-    Texture2DArray(rx::TextureImpl *impl, GLuint id);
-
-    virtual ~Texture2DArray();
-
-    virtual bool isSamplerComplete(const SamplerState &samplerState, const Data &data) const;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(Texture2DArray);
-
-    bool isMipmapComplete() const;
-    bool isLevelComplete(size_t level) const;
-};
-
 }
 
 #endif   // LIBANGLE_TEXTURE_H_

src/libANGLE/renderer/SurfaceImpl.h

@@ -18,11 +18,6 @@ class Display;
 class Config;
 }
 
-namespace gl
-{
-class Texture2D;
-}
-
 namespace rx
 {
 

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -582,15 +582,7 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLenum type)
         const gl::Extents colorSize(1, 1, 1);
         const gl::PixelUnpackState incompleteUnpackState(1);
 
-        gl::Texture* t = NULL;
-        switch (type)
-        {
-          default: UNREACHABLE(); // default falls through to TEXTURE_2D
-          case GL_TEXTURE_2D:       t = new gl::Texture2D(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID);      break;
-          case GL_TEXTURE_CUBE_MAP: t = new gl::TextureCubeMap(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID); break;
-          case GL_TEXTURE_3D:       t = new gl::Texture3D(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID);      break;
-          case GL_TEXTURE_2D_ARRAY: t = new gl::Texture2DArray(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID); break;
-        }
+        gl::Texture* t = new gl::Texture(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID, type);
 
         if (type == GL_TEXTURE_CUBE_MAP)
         {

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -434,7 +434,7 @@ bool TextureD3D::isBaseImageZeroSize() const
         return true;
     }
 
-    if (!gl::IsCubemapTextureTarget(baseImage->getTarget()) && baseImage->getHeight() <= 0)
+    if (!gl::IsCubeMapTextureTarget(baseImage->getTarget()) && baseImage->getHeight() <= 0)
     {
         return true;
     }
@@ -1213,7 +1213,7 @@ gl::Error TextureD3D_Cube::setCompressedImage(GLenum target, size_t level, GLenu
     ASSERT(size.depth == 1);
 
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+    size_t faceIndex = gl::CubeMapTextureTargetToLayerIndex(target);
 
     redefineImage(faceIndex, level, internalFormat, size);
 
@@ -1240,7 +1240,7 @@ gl::Error TextureD3D_Cube::setCompressedSubImage(GLenum target, size_t level, co
 gl::Error TextureD3D_Cube::copyImage(GLenum target, size_t level, const gl::Rectangle &sourceArea, GLenum internalFormat,
                                      const gl::Framebuffer *source)
 {
-    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+    size_t faceIndex = gl::CubeMapTextureTargetToLayerIndex(target);
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, GL_UNSIGNED_BYTE);
 
     gl::Extents size(sourceArea.width, sourceArea.height, 1);
@@ -1287,7 +1287,7 @@ gl::Error TextureD3D_Cube::copyImage(GLenum target, size_t level, const gl::Rect
 gl::Error TextureD3D_Cube::copySubImage(GLenum target, size_t level, const gl::Offset &destOffset, const gl::Rectangle &sourceArea,
                                         const gl::Framebuffer *source)
 {
-    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+    size_t faceIndex = gl::CubeMapTextureTargetToLayerIndex(target);
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, level);
 
@@ -1427,7 +1427,7 @@ unsigned int TextureD3D_Cube::getRenderTargetSerial(const gl::ImageIndex &index)
 
 gl::Error TextureD3D_Cube::getRenderTarget(const gl::ImageIndex &index, RenderTarget **outRT)
 {
-    ASSERT(gl::IsCubemapTextureTarget(index.type));
+    ASSERT(gl::IsCubeMapTextureTarget(index.type));
 
     // ensure the underlying texture is created
     gl::Error error = ensureRenderTarget();
@@ -1605,7 +1605,7 @@ gl::Error TextureD3D_Cube::updateStorageFaceLevel(int faceIndex, int level)
 
     if (image->isDirty())
     {
-        GLenum faceTarget = gl::TextureCubeMap::layerIndexToTarget(faceIndex);
+        GLenum faceTarget = gl::LayerIndexToCubeMapTextureTarget(faceIndex);
         gl::ImageIndex index = gl::ImageIndex::MakeCube(faceTarget, level);
         gl::Box region(0, 0, 0, image->getWidth(), image->getHeight(), 1);
         gl::Error error = commitRegion(index, region);
@@ -1659,12 +1659,12 @@ gl::ImageIndexIterator TextureD3D_Cube::imageIterator() const
 gl::ImageIndex TextureD3D_Cube::getImageIndex(GLint mip, GLint layer) const
 {
     // The "layer" of the image index corresponds to the cube face
-    return gl::ImageIndex::MakeCube(gl::TextureCubeMap::layerIndexToTarget(layer), mip);
+    return gl::ImageIndex::MakeCube(gl::LayerIndexToCubeMapTextureTarget(layer), mip);
 }
 
 bool TextureD3D_Cube::isValidIndex(const gl::ImageIndex &index) const
 {
-    return (mTexStorage && gl::IsCubemapTextureTarget(index.type) &&
+    return (mTexStorage && gl::IsCubeMapTextureTarget(index.type) &&
             index.mipIndex >= 0 && index.mipIndex < mTexStorage->getLevelCount());
 }
 

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

@@ -111,7 +111,7 @@ static bool ImageIndexConflictsWithSRV(const gl::ImageIndex *index, D3D11_SHADER
             unsigned maxSlice = desc.Texture2DArray.FirstArraySlice + desc.Texture2DArray.ArraySize;
 
             // Cube maps can be mapped to Texture2DArray SRVs
-            return (type == GL_TEXTURE_2D_ARRAY || gl::IsCubemapTextureTarget(type)) &&
+            return (type == GL_TEXTURE_2D_ARRAY || gl::IsCubeMapTextureTarget(type)) &&
                    desc.Texture2DArray.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip &&
                    desc.Texture2DArray.FirstArraySlice <= layerIndex && layerIndex < maxSlice;
         }
@@ -121,7 +121,7 @@ static bool ImageIndexConflictsWithSRV(const gl::ImageIndex *index, D3D11_SHADER
             unsigned maxSrvMip = desc.TextureCube.MipLevels + desc.TextureCube.MostDetailedMip;
             maxSrvMip = (desc.TextureCube.MipLevels == -1) ? INT_MAX : maxSrvMip;
 
-            return gl::IsCubemapTextureTarget(type) &&
+            return gl::IsCubeMapTextureTarget(type) &&
                    desc.TextureCube.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip;
         }
 

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

@@ -402,7 +402,7 @@ gl::Error Image9::copyToStorage(TextureStorage *storage, const gl::ImageIndex &i
     }
     else
     {
-        ASSERT(gl::IsCubemapTextureTarget(index.type));
+        ASSERT(gl::IsCubeMapTextureTarget(index.type));
         TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage);
         gl::Error error = storage9->getCubeMapSurface(index.type, index.mipIndex, true, &destSurface);
         if (error.isError())

src/libANGLE/validationES.cpp

@@ -1259,7 +1259,7 @@ bool ValidateCopyTexImageParametersBase(gl::Context* context, GLenum target, GLi
         return false;
     }
 
-    gl::Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+    gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
         context->recordError(Error(GL_INVALID_OPERATION));
@@ -1298,7 +1298,7 @@ bool ValidateCopyTexImageParametersBase(gl::Context* context, GLenum target, GLi
     }
     else
     {
-        if (IsCubemapTextureTarget(target) && width != height)
+        if (IsCubeMapTextureTarget(target) && width != height)
         {
             context->recordError(Error(GL_INVALID_VALUE));
             return false;

src/libANGLE/validationES2.cpp

@@ -62,7 +62,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
             return false;
         }
     }
-    else if (IsCubemapTextureTarget(target))
+    else if (IsCubeMapTextureTarget(target))
     {
         if (!isSubImage && width != height)
         {
@@ -83,7 +83,7 @@ bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level,
         return false;
     }
 
-    gl::Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+    gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
         context->recordError(Error(GL_INVALID_OPERATION));
@@ -799,19 +799,7 @@ bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei le
         break;
     }
 
-    gl::Texture *texture = NULL;
-    switch(target)
-    {
-      case GL_TEXTURE_2D:
-        texture = context->getTexture2D();
-        break;
-      case GL_TEXTURE_CUBE_MAP:
-        texture = context->getTextureCubeMap();
-        break;
-      default:
-        UNREACHABLE();
-    }
-
+    gl::Texture *texture = context->getTargetTexture(target);
     if (!texture || texture->id() == 0)
     {
         context->recordError(Error(GL_INVALID_OPERATION));

src/libANGLE/validationES3.cpp

@@ -366,7 +366,7 @@ bool ValidateES3TexImageParameters(Context *context, GLenum target, GLint level,
         return false;
     }
 
-    gl::Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+    gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
     if (!texture)
     {
         context->recordError(Error(GL_INVALID_OPERATION));
@@ -865,13 +865,10 @@ bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei le
 
     const gl::Caps &caps = context->getCaps();
 
-    gl::Texture *texture = NULL;
     switch (target)
     {
       case GL_TEXTURE_2D:
         {
-            texture = context->getTexture2D();
-
             if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
                 static_cast<GLuint>(height) > caps.max2DTextureSize)
             {
@@ -883,8 +880,6 @@ bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei le
 
       case GL_TEXTURE_CUBE_MAP:
         {
-            texture = context->getTextureCubeMap();
-
             if (width != height)
             {
                 context->recordError(Error(GL_INVALID_VALUE));
@@ -901,8 +896,6 @@ bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei le
 
       case GL_TEXTURE_3D:
         {
-            texture = context->getTexture3D();
-
             if (static_cast<GLuint>(width) > caps.max3DTextureSize ||
                 static_cast<GLuint>(height) > caps.max3DTextureSize ||
                 static_cast<GLuint>(depth) > caps.max3DTextureSize)
@@ -915,8 +908,6 @@ bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei le
 
       case GL_TEXTURE_2D_ARRAY:
         {
-            texture = context->getTexture2DArray();
-
             if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
                 static_cast<GLuint>(height) > caps.max2DTextureSize ||
                 static_cast<GLuint>(depth) > caps.maxArrayTextureLayers)
@@ -932,6 +923,7 @@ bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei le
         return false;
     }
 
+    gl::Texture *texture = context->getTargetTexture(target);
     if (!texture || texture->id() == 0)
     {
         context->recordError(Error(GL_INVALID_OPERATION));

src/libGLESv2/entry_points_gles_2_0.cpp

@@ -742,7 +742,7 @@ void GL_APIENTRY CompressedTexImage2D(GLenum target, GLint level, GLenum interna
         }
 
         Extents size(width, height, 1);
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->setCompressedImage(target, level, internalformat, size, context->getState().getUnpackState(), 
                                                   reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
@@ -787,7 +787,7 @@ void GL_APIENTRY CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffs
 
 
         Box area(xoffset, yoffset, 0, width, height, 1);
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->setCompressedSubImage(target, level, area, format, context->getState().getUnpackState(),
                                                      reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
@@ -824,7 +824,7 @@ void GL_APIENTRY CopyTexImage2D(GLenum target, GLint level, GLenum internalforma
         Rectangle sourceArea(x, y, width, height);
 
         const Framebuffer *framebuffer = context->getState().getReadFramebuffer();
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->copyImage(target, level, sourceArea, internalformat, framebuffer);
         if (error.isError())
         {
@@ -861,7 +861,7 @@ void GL_APIENTRY CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GL
         Rectangle sourceArea(x, y, width, height);
 
         const Framebuffer *framebuffer = context->getState().getReadFramebuffer();
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->copySubImage(target, level, destOffset, sourceArea, framebuffer);
         if (error.isError())
         {
@@ -1379,7 +1379,7 @@ void GL_APIENTRY FramebufferTexture2D(GLenum target, GLenum attachment, GLenum t
             }
             else
             {
-                ASSERT(IsCubemapTextureTarget(textarget));
+                ASSERT(IsCubeMapTextureTarget(textarget));
                 index = ImageIndex::MakeCube(textarget, level);
             }
 
@@ -1493,14 +1493,10 @@ void GL_APIENTRY GenerateMipmap(GLenum target)
         }
 
         // Cube completeness check
-        if (target == GL_TEXTURE_CUBE_MAP)
+        if (target == GL_TEXTURE_CUBE_MAP && !texture->isCubeComplete())
         {
-            TextureCubeMap *textureCube = static_cast<TextureCubeMap *>(texture);
-            if (!textureCube->isCubeComplete())
-            {
-                context->recordError(Error(GL_INVALID_OPERATION));
-                return;
-            }
+            context->recordError(Error(GL_INVALID_OPERATION));
+            return;
         }
 
         Error error = texture->generateMipmaps();
@@ -3555,7 +3551,7 @@ void GL_APIENTRY TexImage2D(GLenum target, GLint level, GLint internalformat, GL
         }
 
         Extents size(width, height, 1);
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->setImage(target, level, internalformat, size, format, type, context->getState().getUnpackState(),
                                         reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())
@@ -3696,7 +3692,7 @@ void GL_APIENTRY TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint
         }
 
         Box area(xoffset, yoffset, 0, width, height, 1);
-        Texture *texture = context->getTargetTexture(IsCubemapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
+        Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
         Error error = texture->setSubImage(target, level, area, format, type, context->getState().getUnpackState(),
                                            reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())

tests/angle_implementation_unit_tests/ImageIndexIterator_unittest.cpp

@@ -6,8 +6,9 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+
+#include "common/utilities.h"
 #include "libANGLE/ImageIndex.h"
-#include "libANGLE/Texture.h"
 
 using namespace gl;
 
@@ -55,7 +56,7 @@ TEST(ImageIndexTest, IteratorCube)
             EXPECT_TRUE(iter.hasNext());
             ImageIndex nextIndex = iter.next();
 
-            GLenum cubeTarget = TextureCubeMap::layerIndexToTarget(layer);
+            GLenum cubeTarget = LayerIndexToCubeMapTextureTarget(layer);
 
             EXPECT_EQ(cubeTarget, nextIndex.type);
             EXPECT_EQ(mip, nextIndex.mipIndex);