Unifying the various texture interfaces where possible

Also fixed diamond inheritance pattern that was causing trouble
on Windows 8

BUG=angle:688, angle:720
Change-Id: I678826bd4f3927c68ca1eb2e018dbb5aad33a8cc
Reviewed-on: https://chromium-review.googlesource.com/211037
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Tested-by: Brandon Jones <bajones@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>

11 files changed, 308 insertions, 340 deletions

diff --git a/src/libGLESv2/FramebufferAttachment.cpp b/src/libGLESv2/FramebufferAttachment.cpp
index e7855b1c..6f40edf4 100644
--- a/src/libGLESv2/FramebufferAttachment.cpp
+++ b/src/libGLESv2/FramebufferAttachment.cpp
@@ -95,7 +95,7 @@ rx::RenderTarget *Texture2DAttachment::getRenderTarget()
 
 rx::RenderTarget *Texture2DAttachment::getDepthStencil()
 {
-    return mTexture2D->getDepthSencil(mLevel);
+    return mTexture2D->getDepthStencil(mLevel);
 }
 
 rx::TextureStorage *Texture2DAttachment::getTextureStorage()
diff --git a/src/libGLESv2/Texture.cpp b/src/libGLESv2/Texture.cpp
index 67f9a090..87e03042 100644
--- a/src/libGLESv2/Texture.cpp
+++ b/src/libGLESv2/Texture.cpp
@@ -44,6 +44,7 @@ GLenum Texture::getTarget() const
 void Texture::setUsage(GLenum usage)
 {
     mUsage = usage;
+    getImplementation()->setUsage(usage);
 }
 
 void Texture::getSamplerStateWithNativeOffset(SamplerState *sampler)
@@ -99,6 +100,11 @@ rx::TextureStorageInterface *Texture::getNativeTexture()
     return getImplementation()->getNativeTexture();
 }
 
+void Texture::generateMipmaps()
+{
+    getImplementation()->generateMipmaps();
+}
+
 void Texture::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
 {
     getImplementation()->copySubImage(target, level, xoffset, yoffset, zoffset, x, y, width, height, source);
@@ -125,6 +131,11 @@ int Texture::mipLevels() const
     return log2(std::max(std::max(getBaseLevelWidth(), getBaseLevelHeight()), getBaseLevelDepth())) + 1;
 }
 
+const rx::Image *Texture::getBaseLevelImage() const
+{
+    return (getImplementation()->getLayerCount(0) > 0 ? getImplementation()->getImage(0, 0) : NULL);
+}
+
 Texture2D::Texture2D(rx::Texture2DImpl *impl, GLuint id)
     : Texture(id, GL_TEXTURE_2D),
       mTexture(impl)
@@ -143,16 +154,10 @@ Texture2D::~Texture2D()
     }
 }
 
-void Texture2D::setUsage(GLenum usage)
-{
-    mUsage = usage;
-    mTexture->setUsage(usage);
-}
-
 GLsizei Texture2D::getWidth(GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(level)->getWidth();
+        return mTexture->getImage(level, 0)->getWidth();
     else
         return 0;
 }
@@ -160,7 +165,7 @@ GLsizei Texture2D::getWidth(GLint level) const
 GLsizei Texture2D::getHeight(GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(level)->getHeight();
+        return mTexture->getImage(level, 0)->getHeight();
     else
         return 0;
 }
@@ -168,7 +173,7 @@ GLsizei Texture2D::getHeight(GLint level) const
 GLenum Texture2D::getInternalFormat(GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(level)->getInternalFormat();
+        return mTexture->getImage(level, 0)->getInternalFormat();
     else
         return GL_NONE;
 }
@@ -176,25 +181,16 @@ GLenum Texture2D::getInternalFormat(GLint level) const
 GLenum Texture2D::getActualFormat(GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(level)->getActualFormat();
+        return mTexture->getImage(level, 0)->getActualFormat();
     else
         return GL_NONE;
 }
 
-void Texture2D::redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    releaseTexImage();
-
-    mTexture->redefineImage(level, internalformat, width, height);
-}
-
 void Texture2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    GLenum sizedInternalFormat = GetSizedInternalFormat(internalFormat, type);
-
-    redefineImage(level, sizedInternalFormat, width, height);
+    releaseTexImage();
 
-    mTexture->setImage(level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_2D, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void Texture2D::bindTexImage(egl::Surface *surface)
@@ -220,36 +216,33 @@ void Texture2D::releaseTexImage()
 
 void Texture2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
 {
-    // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    redefineImage(level, format, width, height);
+    releaseTexImage();
 
-    mTexture->setCompressedImage(level, format, width, height, imageSize, pixels);
+    mTexture->setCompressedImage(GL_TEXTURE_2D, level, format, width, height, 1, imageSize, pixels);
 }
 
 void Texture2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->subImage(level, xoffset, yoffset, width, height, format, type, unpack, pixels);
+    mTexture->subImage(GL_TEXTURE_2D, level, xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels);
 }
 
 void Texture2D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
 {
-    mTexture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, pixels);
+    mTexture->subImageCompressed(GL_TEXTURE_2D, level, xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels);
 }
 
 void Texture2D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source)
 {
-    GLenum sizedInternalFormat = GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
-
-    redefineImage(level, sizedInternalFormat, width, height);
+    releaseTexImage();
 
-    mTexture->copyImage(level, format, x, y, width, height, source);
+    mTexture->copyImage(GL_TEXTURE_2D, level, format, x, y, width, height, source);
 }
 
 void Texture2D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
     mImmutable = true;
 
-    mTexture->storage(levels, internalformat, width, height);
+    mTexture->storage(GL_TEXTURE_2D, levels, internalformat, width, height, 1);
 }
 
 bool Texture2D::isCompressed(GLint level) const
@@ -264,36 +257,24 @@ bool Texture2D::isDepth(GLint level) const
 
 void Texture2D::generateMipmaps()
 {
-    // Purge array levels 1 through q and reset them to represent the generated mipmap levels.
-    int levelCount = mipLevels();
-    for (int level = 1; level < levelCount; level++)
-    {
-        redefineImage(level, getBaseLevelInternalFormat(),
-                      std::max(getBaseLevelWidth() >> level, 1),
-                      std::max(getBaseLevelHeight() >> level, 1));
-    }
+    releaseTexImage();
 
     mTexture->generateMipmaps();
 }
 
-const rx::Image *Texture2D::getBaseLevelImage() const
-{
-    return mTexture->getImage(0);
-}
-
 unsigned int Texture2D::getRenderTargetSerial(GLint level)
 {
-    return mTexture->getRenderTargetSerial(level);
+    return mTexture->getRenderTargetSerial(level, 0);
 }
 
 rx::RenderTarget *Texture2D::getRenderTarget(GLint level)
 {
-    return mTexture->getRenderTarget(level);
+    return mTexture->getRenderTarget(level, 0);
 }
 
-rx::RenderTarget *Texture2D::getDepthSencil(GLint level)
+rx::RenderTarget *Texture2D::getDepthStencil(GLint level)
 {
-    return mTexture->getDepthSencil(level);
+    return mTexture->getDepthStencil(level, 0);
 }
 
 TextureCubeMap::TextureCubeMap(rx::TextureCubeImpl *impl, GLuint id)
@@ -307,16 +288,10 @@ TextureCubeMap::~TextureCubeMap()
     SafeDelete(mTexture);
 }
 
-void TextureCubeMap::setUsage(GLenum usage)
-{
-    mUsage = usage;
-    mTexture->setUsage(usage);
-}
-
 GLsizei TextureCubeMap::getWidth(GLenum target, GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(target, level)->getWidth();
+        return mTexture->getImage(level, targetToLayerIndex(target))->getWidth();
     else
         return 0;
 }
@@ -324,7 +299,7 @@ GLsizei TextureCubeMap::getWidth(GLenum target, GLint level) const
 GLsizei TextureCubeMap::getHeight(GLenum target, GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(target, level)->getHeight();
+        return mTexture->getImage(level, targetToLayerIndex(target))->getHeight();
     else
         return 0;
 }
@@ -332,7 +307,7 @@ GLsizei TextureCubeMap::getHeight(GLenum target, GLint level) const
 GLenum TextureCubeMap::getInternalFormat(GLenum target, GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(target, level)->getInternalFormat();
+        return mTexture->getImage(level, targetToLayerIndex(target))->getInternalFormat();
     else
         return GL_NONE;
 }
@@ -340,54 +315,54 @@ GLenum TextureCubeMap::getInternalFormat(GLenum target, GLint level) const
 GLenum TextureCubeMap::getActualFormat(GLenum target, GLint level) const
 {
     if (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mTexture->getImage(target, level)->getActualFormat();
+        return mTexture->getImage(level, targetToLayerIndex(target))->getActualFormat();
     else
         return GL_NONE;
 }
 
 void TextureCubeMap::setImagePosX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(0, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setImageNegX(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(1, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setImagePosY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(2, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setImageNegY(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(3, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setImagePosZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(4, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setImageNegZ(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(5, level, width, height, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, level, width, height, 1, internalFormat, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
 {
-    mTexture->setCompressedImage(target, level, format, width, height, imageSize, pixels);
+    mTexture->setCompressedImage(target, level, format, width, height, 1, imageSize, pixels);
 }
 
 void TextureCubeMap::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->subImage(target, level, xoffset, yoffset, width, height, format, type, unpack, pixels);
+    mTexture->subImage(target, level, xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels);
 }
 
 void TextureCubeMap::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
 {
-    mTexture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, pixels);
+    mTexture->subImageCompressed(target, level, xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels);
 }
 
 // Tests for cube texture completeness. [OpenGL ES 2.0.24] section 3.7.10 page 81.
@@ -415,34 +390,44 @@ void TextureCubeMap::storage(GLsizei levels, GLenum internalformat, GLsizei size
 {
     mImmutable = true;
 
-    mTexture->storage(levels, internalformat, size);
+    mTexture->storage(GL_TEXTURE_CUBE_MAP, levels, internalformat, size, size, 1);
 }
 
-void TextureCubeMap::generateMipmaps()
+unsigned int TextureCubeMap::getRenderTargetSerial(GLenum target, GLint level)
 {
-    mTexture->generateMipmaps();
+    return mTexture->getRenderTargetSerial(level, targetToLayerIndex(target));
 }
 
-const rx::Image *TextureCubeMap::getBaseLevelImage() const
+int TextureCubeMap::targetToLayerIndex(GLenum target)
 {
-    // Note: if we are not cube-complete, there is no single base level image that can describe all
-    // cube faces, so this method is only well-defined for a cube-complete base level.
-    return mTexture->getImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0);
+    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);
+
+    return target - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
 }
 
-unsigned int TextureCubeMap::getRenderTargetSerial(GLenum target, GLint level)
+GLenum TextureCubeMap::layerIndexToTarget(GLint layer)
 {
-    return mTexture->getRenderTargetSerial(target, level);
+    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);
+
+    return GL_TEXTURE_CUBE_MAP_POSITIVE_X + layer;
 }
 
 rx::RenderTarget *TextureCubeMap::getRenderTarget(GLenum target, GLint level)
 {
-    return mTexture->getRenderTarget(target, level);
+    return mTexture->getRenderTarget(level, targetToLayerIndex(target));
 }
 
 rx::RenderTarget *TextureCubeMap::getDepthStencil(GLenum target, GLint level)
 {
-    return mTexture->getDepthStencil(target, level);
+    return mTexture->getDepthStencil(level, targetToLayerIndex(target));
 }
 
 Texture3D::Texture3D(rx::Texture3DImpl *impl, GLuint id)
@@ -456,35 +441,29 @@ Texture3D::~Texture3D()
     SafeDelete(mTexture);
 }
 
-void Texture3D::setUsage(GLenum usage)
-{
-    mUsage = usage;
-    mTexture->setUsage(usage);
-}
-
 GLsizei Texture3D::getWidth(GLint level) const
 {
-    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level)->getWidth() : 0;
+    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level, 0)->getWidth() : 0;
 }
 
 GLsizei Texture3D::getHeight(GLint level) const
 {
-    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level)->getHeight() : 0;
+    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level, 0)->getHeight() : 0;
 }
 
 GLsizei Texture3D::getDepth(GLint level) const
 {
-    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level)->getDepth() : 0;
+    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level, 0)->getDepth() : 0;
 }
 
 GLenum Texture3D::getInternalFormat(GLint level) const
 {
-    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level)->getInternalFormat() : GL_NONE;
+    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level, 0)->getInternalFormat() : GL_NONE;
 }
 
 GLenum Texture3D::getActualFormat(GLint level) const
 {
-    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level)->getActualFormat() : GL_NONE;
+    return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS) ? mTexture->getImage(level, 0)->getActualFormat() : GL_NONE;
 }
 
 bool Texture3D::isCompressed(GLint level) const
@@ -499,39 +478,29 @@ bool Texture3D::isDepth(GLint level) const
 
 void Texture3D::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(level, width, height, depth, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_3D, level, width, height, depth, internalFormat, format, type, unpack, pixels);
 }
 
 void Texture3D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
-    mTexture->setCompressedImage(level, format, width, height, depth, imageSize, pixels);
+    mTexture->setCompressedImage(GL_TEXTURE_3D, level, format, width, height, depth, imageSize, pixels);
 }
 
 void Texture3D::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels);
+    mTexture->subImage(GL_TEXTURE_3D, level, xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels);
 }
 
 void Texture3D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
-    mTexture->subImageCompressed(level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels);
+    mTexture->subImageCompressed(GL_TEXTURE_3D, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels);
 }
 
 void Texture3D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
     mImmutable = true;
 
-    mTexture->storage(levels, internalformat, width, height, depth);
-}
-
-void Texture3D::generateMipmaps()
-{
-    mTexture->generateMipmaps();
-}
-
-const rx::Image *Texture3D::getBaseLevelImage() const
-{
-    return mTexture->getImage(0);
+    mTexture->storage(GL_TEXTURE_3D, levels, internalformat, width, height, depth);
 }
 
 unsigned int Texture3D::getRenderTargetSerial(GLint level, GLint layer)
@@ -561,12 +530,6 @@ Texture2DArray::~Texture2DArray()
     SafeDelete(mTexture);
 }
 
-void Texture2DArray::setUsage(GLenum usage)
-{
-    mUsage = usage;
-    mTexture->setUsage(usage);
-}
-
 GLsizei Texture2DArray::getWidth(GLint level) const
 {
     return (level < IMPLEMENTATION_MAX_TEXTURE_LEVELS && mTexture->getLayerCount(level) > 0) ? mTexture->getImage(level, 0)->getWidth() : 0;
@@ -604,39 +567,29 @@ bool Texture2DArray::isDepth(GLint level) const
 
 void Texture2DArray::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->setImage(level, width, height, depth, internalFormat, format, type, unpack, pixels);
+    mTexture->setImage(GL_TEXTURE_2D_ARRAY, level, width, height, depth, internalFormat, format, type, unpack, pixels);
 }
 
 void Texture2DArray::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
-    mTexture->setCompressedImage(level, format, width, height, depth, imageSize, pixels);
+    mTexture->setCompressedImage(GL_TEXTURE_2D_ARRAY, level, format, width, height, depth, imageSize, pixels);
 }
 
 void Texture2DArray::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels)
 {
-    mTexture->subImage(level, xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels);
+    mTexture->subImage(GL_TEXTURE_2D_ARRAY, level, xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels);
 }
 
 void Texture2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
-    mTexture->subImageCompressed(level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels);
+    mTexture->subImageCompressed(GL_TEXTURE_2D_ARRAY, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels);
 }
 
 void Texture2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
     mImmutable = true;
 
-    mTexture->storage(levels, internalformat, width, height, depth);
-}
-
-void Texture2DArray::generateMipmaps()
-{
-    mTexture->generateMipmaps();
-}
-
-const rx::Image *Texture2DArray::getBaseLevelImage() const
-{
-    return (mTexture->getLayerCount(0) > 0 ? mTexture->getImage(0, 0) : NULL);
+    mTexture->storage(GL_TEXTURE_2D_ARRAY, levels, internalformat, width, height, depth);
 }
 
 unsigned int Texture2DArray::getRenderTargetSerial(GLint level, GLint layer)
diff --git a/src/libGLESv2/Texture.h b/src/libGLESv2/Texture.h
index 928a4dd3..eaa4cf7b 100644
--- a/src/libGLESv2/Texture.h
+++ b/src/libGLESv2/Texture.h
@@ -51,7 +51,7 @@ class Texture : public RefCountObject
     SamplerState &getSamplerState() { return mSamplerState; }
     void getSamplerStateWithNativeOffset(SamplerState *sampler);
 
-    virtual void setUsage(GLenum usage);
+    void setUsage(GLenum usage);
     GLenum getUsage() const;
 
     GLint getBaseLevelWidth() const;
@@ -63,7 +63,7 @@ class Texture : public RefCountObject
 
     rx::TextureStorageInterface *getNativeTexture();
 
-    virtual void generateMipmaps() = 0;
+    virtual void generateMipmaps();
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
 
     unsigned int getTextureSerial();
@@ -89,7 +89,7 @@ class Texture : public RefCountObject
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture);
 
-    virtual const rx::Image *getBaseLevelImage() const = 0;
+    const rx::Image *getBaseLevelImage() const;
 };
 
 class Texture2D : public Texture
@@ -99,8 +99,6 @@ class Texture2D : public Texture
 
     ~Texture2D();
 
-    virtual void setUsage(GLenum usage);
-
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
     GLenum getInternalFormat(GLint level) const;
@@ -128,15 +126,11 @@ class Texture2D : public Texture
   protected:
     friend class Texture2DAttachment;
     rx::RenderTarget *getRenderTarget(GLint level);
-    rx::RenderTarget *getDepthSencil(GLint level);
+    rx::RenderTarget *getDepthStencil(GLint level);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture2D);
 
-    virtual const rx::Image *getBaseLevelImage() const;
-
-    void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height);
-
     rx::Texture2DImpl *mTexture;
     egl::Surface *mSurface;
 };
@@ -148,8 +142,6 @@ class TextureCubeMap : public Texture
 
     ~TextureCubeMap();
 
-    virtual void setUsage(GLenum usage);
-
     GLsizei getWidth(GLenum target, GLint level) const;
     GLsizei getHeight(GLenum target, GLint level) const;
     GLenum getInternalFormat(GLenum target, GLint level) const;
@@ -173,10 +165,11 @@ class TextureCubeMap : public Texture
 
     bool isCubeComplete() const;
 
-    virtual void generateMipmaps();
-
     unsigned int getRenderTargetSerial(GLenum target, GLint level);
 
+    static int targetToLayerIndex(GLenum target);
+    static GLenum layerIndexToTarget(GLint layer);
+
     virtual rx::TextureImpl *getImplementation() { return mTexture; }
     virtual const rx::TextureImpl *getImplementation() const { return mTexture; }
 
@@ -188,8 +181,6 @@ class TextureCubeMap : public Texture
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureCubeMap);
 
-    virtual const rx::Image *getBaseLevelImage() const;
-
     rx::TextureCubeImpl *mTexture;
 };
 
@@ -200,8 +191,6 @@ class Texture3D : public Texture
 
     ~Texture3D();
 
-    virtual void setUsage(GLenum usage);
-
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
     GLsizei getDepth(GLint level) const;
@@ -216,8 +205,6 @@ class Texture3D : public Texture
     void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
     void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
-    virtual void generateMipmaps();
-
     unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
     virtual rx::TextureImpl *getImplementation() { return mTexture; }
@@ -231,8 +218,6 @@ class Texture3D : public Texture
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture3D);
 
-    virtual const rx::Image *getBaseLevelImage() const;
-
     rx::Texture3DImpl *mTexture;
 };
 
@@ -243,8 +228,6 @@ class Texture2DArray : public Texture
 
     ~Texture2DArray();
 
-    virtual void setUsage(GLenum usage);
-
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
     GLsizei getLayers(GLint level) const;
@@ -259,8 +242,6 @@ class Texture2DArray : public Texture
     void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
     void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
-    virtual void generateMipmaps();
-
     unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
     virtual rx::TextureImpl *getImplementation() { return mTexture; }
@@ -274,8 +255,6 @@ class Texture2DArray : public Texture
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture2DArray);
 
-    virtual const rx::Image *getBaseLevelImage() const;
-
     rx::Texture2DArrayImpl *mTexture;
 };
 
diff --git a/src/libGLESv2/renderer/TextureImpl.h b/src/libGLESv2/renderer/TextureImpl.h
index e609c2a4..2aa0d553 100644
--- a/src/libGLESv2/renderer/TextureImpl.h
+++ b/src/libGLESv2/renderer/TextureImpl.h
@@ -39,13 +39,28 @@ class TextureImpl
     // higher level code should not rely on it.
     virtual TextureStorageInterface *getNativeTexture() = 0;
 
+    virtual Image *getImage(int level, int layer) const = 0;
+    virtual GLsizei getLayerCount(int level) const = 0;
+
+    virtual bool hasDirtyImages() const = 0;
+    virtual void resetDirty() = 0;
     virtual void setUsage(GLenum usage) = 0;
 
     virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const = 0;
 
+    virtual void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) = 0;
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) = 0;
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
+    virtual void storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
 
     virtual void generateMipmaps() = 0;
+
+    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
 };
 
 class Texture2DImpl : public TextureImpl
@@ -53,24 +68,8 @@ class Texture2DImpl : public TextureImpl
   public:
     virtual ~Texture2DImpl() {}
 
-    virtual Image *getImage(int level) const = 0;
-
     virtual void bindTexImage(egl::Surface *surface) = 0;
     virtual void releaseTexImage() = 0;
-
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) = 0;
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) = 0;
-    virtual void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) = 0;
-
-    virtual unsigned int getRenderTargetSerial(GLint level) = 0;
-
-    virtual RenderTarget *getRenderTarget(GLint level) = 0;
-    virtual RenderTarget *getDepthSencil(GLint level) = 0;
-
-    virtual void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height) = 0;
 };
 
 class TextureCubeImpl : public TextureImpl
@@ -78,60 +77,19 @@ class TextureCubeImpl : public TextureImpl
   public:
     virtual ~TextureCubeImpl() {}
 
-    virtual Image *getImage(GLenum target, int level) const = 0;
-
     virtual bool isCubeComplete() const = 0;
-
-    virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) = 0;
-    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) = 0;
-    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei size) = 0;
-
-    virtual unsigned int getRenderTargetSerial(GLenum target, GLint level) = 0;
-
-    virtual RenderTarget *getRenderTarget(GLenum target, GLint level) = 0;
-    virtual RenderTarget *getDepthStencil(GLenum target, GLint level) = 0;
 };
 
 class Texture3DImpl : public TextureImpl
 {
   public:
     virtual ~Texture3DImpl() {}
-
-    virtual Image *getImage(int level) const = 0;
-
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) = 0;
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) = 0;
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
-
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
-
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
-    virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
 };
 
 class Texture2DArrayImpl : public TextureImpl
 {
   public:
     virtual ~Texture2DArrayImpl() {}
-
-    virtual Image *getImage(int level, int layer) const = 0;
-    virtual GLsizei getLayerCount(int level) const = 0;
-
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) = 0;
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) = 0;
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
-
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
-
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
-    virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
 };
 
 }
diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.cpp b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
index 4cbe5d65..b33c471b 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
@@ -12,6 +12,7 @@
 #include "libEGL/Surface.h"
 #include "libGLESv2/Buffer.h"
 #include "libGLESv2/Framebuffer.h"
+#include "libGLESv2/Texture.h"
 #include "libGLESv2/main.h"
 #include "libGLESv2/formatutils.h"
 #include "libGLESv2/renderer/BufferImpl.h"
@@ -58,12 +59,6 @@ TextureD3D::~TextureD3D()
 {
 }
 
-TextureD3D *TextureD3D::makeTextureD3D(TextureImpl *texture)
-{
-    ASSERT(HAS_DYNAMIC_TYPE(TextureD3D*, texture));
-    return static_cast<TextureD3D*>(texture);
-}
-
 GLint TextureD3D::getBaseLevelWidth() const
 {
     const Image *baseImage = getBaseLevelImage();
@@ -250,15 +245,17 @@ TextureStorageInterface *TextureD3D_2D::getNativeTexture()
     return storage;
 }
 
-Image *TextureD3D_2D::getImage(int level) const
+Image *TextureD3D_2D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
+    ASSERT(layer == 0);
     return mImageArray[level];
 }
 
-void TextureD3D_2D::setUsage(GLenum usage)
+GLsizei TextureD3D_2D::getLayerCount(int level) const
 {
-    mUsage = usage;
+    ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
+    return 1;
 }
 
 GLsizei TextureD3D_2D::getWidth(GLint level) const
@@ -298,17 +295,21 @@ bool TextureD3D_2D::isDepth(GLint level) const
     return gl::GetInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-void TextureD3D_2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_2D::setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D && depth == 1);
+
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, type);
 
     bool fastUnpacked = false;
 
+    redefineImage(level, sizedInternalFormat, width, height);
+
     // Attempt a fast gpu copy of the pixel data to the surface
     if (isFastUnpackable(unpack, sizedInternalFormat) && isLevelComplete(level))
     {
         // Will try to create RT storage if it does not exist
-        RenderTarget *destRenderTarget = getRenderTarget(level);
+        RenderTarget *destRenderTarget = getRenderTarget(level, 0);
         gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), 1);
 
         if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget))
@@ -326,18 +327,25 @@ void TextureD3D_2D::setImage(GLint level, GLsizei width, GLsizei height, GLenum
     }
 }
 
-void TextureD3D_2D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
+void TextureD3D_2D::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D && depth == 1);
+
+    // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
+    redefineImage(level, format, width, height);
+
     TextureD3D::setCompressedImage(imageSize, pixels, mImageArray[level]);
 }
 
-void TextureD3D_2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_2D::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D && depth == 1 && zoffset == 0);
+
     bool fastUnpacked = false;
 
     if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level))
     {
-        RenderTarget *renderTarget = getRenderTarget(level);
+        RenderTarget *renderTarget = getRenderTarget(level, 0);
         gl::Box destArea(xoffset, yoffset, 0, width, height, 1);
 
         if (renderTarget && fastUnpackPixels(unpack, pixels, destArea, getInternalFormat(level), type, renderTarget))
@@ -355,16 +363,23 @@ void TextureD3D_2D::subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei
     }
 }
 
-void TextureD3D_2D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
+void TextureD3D_2D::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D && depth == 1 && zoffset == 0);
+
     if (TextureD3D::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[level]))
     {
         commitRect(level, xoffset, yoffset, width, height);
     }
 }
 
-void TextureD3D_2D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
+void TextureD3D_2D::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
+    ASSERT(target == GL_TEXTURE_2D);
+
+    GLenum sizedInternalFormat = gl::GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
+    redefineImage(level, sizedInternalFormat, width, height);
+
     if (!mImageArray[level]->isRenderableFormat())
     {
         mImageArray[level]->copy(0, 0, 0, x, y, width, height, source);
@@ -390,6 +405,8 @@ void TextureD3D_2D::copyImage(GLint level, GLenum format, GLint x, GLint y, GLsi
 
 void TextureD3D_2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
+    ASSERT(target == GL_TEXTURE_2D && zoffset == 0);
+
     // can only make our texture storage to a render target if level 0 is defined (with a width & height) and
     // the current level we're copying to is defined (with appropriate format, width & height)
     bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0);
@@ -420,8 +437,10 @@ void TextureD3D_2D::copySubImage(GLenum target, GLint level, GLint xoffset, GLin
     }
 }
 
-void TextureD3D_2D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+void TextureD3D_2D::storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
+    ASSERT(target == GL_TEXTURE_2D && depth == 1);
+
     for (int level = 0; level < levels; level++)
     {
         GLsizei levelWidth = std::max(1, width >> level);
@@ -538,7 +557,14 @@ void TextureD3D_2D::releaseTexImage()
 
 void TextureD3D_2D::generateMipmaps()
 {
+    // Purge array levels 1 through q and reset them to represent the generated mipmap levels.
     int levelCount = mipLevels();
+    for (int level = 1; level < levelCount; level++)
+    {
+        redefineImage(level, getBaseLevelInternalFormat(),
+                      std::max(getBaseLevelWidth() >> level, 1),
+                      std::max(getBaseLevelHeight() >> level, 1));
+    }
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
@@ -558,13 +584,16 @@ void TextureD3D_2D::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_2D::getRenderTargetSerial(GLint level)
+unsigned int TextureD3D_2D::getRenderTargetSerial(GLint level, GLint layer)
 {
+    ASSERT(layer == 0);
     return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level) : 0);
 }
 
-RenderTarget *TextureD3D_2D::getRenderTarget(GLint level)
+RenderTarget *TextureD3D_2D::getRenderTarget(GLint level, GLint layer)
 {
+    ASSERT(layer == 0);
+
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
     {
@@ -582,8 +611,10 @@ RenderTarget *TextureD3D_2D::getRenderTarget(GLint level)
     return mTexStorage->getRenderTarget(level);
 }
 
-RenderTarget *TextureD3D_2D::getDepthSencil(GLint level)
+RenderTarget *TextureD3D_2D::getDepthStencil(GLint level, GLint layer)
 {
+    ASSERT(layer == 0);
+
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
     {
@@ -866,32 +897,37 @@ TextureStorageInterface *TextureD3D_Cube::getNativeTexture()
     return storage;
 }
 
-Image *TextureD3D_Cube::getImage(GLenum target, int level) const
+Image *TextureD3D_Cube::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    return mImageArray[targetToIndex(target)][level];
+    ASSERT(layer < 6);
+    return mImageArray[layer][level];
 }
 
-void TextureD3D_Cube::setUsage(GLenum usage)
+GLsizei TextureD3D_Cube::getLayerCount(int level) const
 {
-    mUsage = usage;
+    ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
+    return 6;
 }
 
-GLenum TextureD3D_Cube::getInternalFormat(GLenum target, GLint level) const
+GLenum TextureD3D_Cube::getInternalFormat(GLint level, GLint layer) const
 {
     if (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)
-        return mImageArray[targetToIndex(target)][level]->getInternalFormat();
+        return mImageArray[layer][level]->getInternalFormat();
     else
         return GL_NONE;
 }
 
-bool TextureD3D_Cube::isDepth(GLenum target, GLint level) const
+bool TextureD3D_Cube::isDepth(GLint level, GLint layer) const
 {
-    return gl::GetInternalFormatInfo(getInternalFormat(target, level)).depthBits > 0;
+    return gl::GetInternalFormatInfo(getInternalFormat(level, layer)).depthBits > 0;
 }
 
-void TextureD3D_Cube::setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_Cube::setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(depth == 1);
+
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, type);
 
     redefineImage(faceIndex, level, sizedInternalFormat, width, height);
@@ -899,27 +935,36 @@ void TextureD3D_Cube::setImage(int faceIndex, GLint level, GLsizei width, GLsize
     TextureD3D::setImage(unpack, type, pixels, mImageArray[faceIndex][level]);
 }
 
-void TextureD3D_Cube::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels)
+void TextureD3D_Cube::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(depth == 1);
+
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    int faceIndex = targetToIndex(target);
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+
     redefineImage(faceIndex, level, format, width, height);
 
     TextureD3D::setCompressedImage(imageSize, pixels, mImageArray[faceIndex][level]);
 }
 
-void TextureD3D_Cube::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_Cube::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
-    int faceIndex = targetToIndex(target);
+    ASSERT(depth == 1 && zoffset == 0);
+
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+
     if (TextureD3D::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, mImageArray[faceIndex][level]))
     {
         commitRect(faceIndex, level, xoffset, yoffset, width, height);
     }
 }
 
-void TextureD3D_Cube::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels)
+void TextureD3D_Cube::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
-    int faceIndex = targetToIndex(target);
+    ASSERT(depth == 1 && zoffset == 0);
+
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
+
     if (TextureD3D::subImageCompressed(xoffset, yoffset, 0, width, height, 1, format, imageSize, pixels, mImageArray[faceIndex][level]))
     {
         commitRect(faceIndex, level, xoffset, yoffset, width, height);
@@ -928,7 +973,7 @@ void TextureD3D_Cube::subImageCompressed(GLenum target, GLint level, GLint xoffs
 
 void TextureD3D_Cube::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
-    int faceIndex = targetToIndex(target);
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(format, GL_UNSIGNED_BYTE);
 
     redefineImage(faceIndex, level, sizedInternalFormat, width, height);
@@ -960,7 +1005,7 @@ void TextureD3D_Cube::copyImage(GLenum target, GLint level, GLenum format, GLint
 
 void TextureD3D_Cube::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
-    int faceIndex = targetToIndex(target);
+    int faceIndex = gl::TextureCubeMap::targetToLayerIndex(target);
 
     // We can only make our texture storage to a render target if the level we're copying *to* is complete
     // and the base level is cube-complete. The base level must be cube complete (common case) because we cannot
@@ -992,11 +1037,14 @@ void TextureD3D_Cube::copySubImage(GLenum target, GLint level, GLint xoffset, GL
     }
 }
 
-void TextureD3D_Cube::storage(GLsizei levels, GLenum internalformat, GLsizei size)
+void TextureD3D_Cube::storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
+    ASSERT(width == height);
+    ASSERT(depth == 1);
+
     for (int level = 0; level < levels; level++)
     {
-        GLsizei mipSize = std::max(1, size >> level);
+        GLsizei mipSize = std::max(1, width >> level);
         for (int faceIndex = 0; faceIndex < 6; faceIndex++)
         {
             mImageArray[faceIndex][level]->redefine(mRenderer, GL_TEXTURE_CUBE_MAP, internalformat, mipSize, mipSize, 1, true);
@@ -1013,7 +1061,7 @@ void TextureD3D_Cube::storage(GLsizei levels, GLenum internalformat, GLsizei siz
 
     mImmutable = true;
 
-    setCompleteTexStorage(new TextureStorageInterfaceCube(mRenderer, internalformat, IsRenderTargetUsage(mUsage), size, levels));
+    setCompleteTexStorage(new TextureStorageInterfaceCube(mRenderer, internalformat, IsRenderTargetUsage(mUsage), width, levels));
 }
 
 bool TextureD3D_Cube::isSamplerComplete(const gl::SamplerState &samplerState) const
@@ -1023,7 +1071,7 @@ bool TextureD3D_Cube::isSamplerComplete(const gl::SamplerState &samplerState) co
     bool mipmapping = IsMipmapFiltered(samplerState);
 
     // TODO(geofflang): use context's texture caps
-    if (!mRenderer->getRendererTextureCaps().get(getInternalFormat(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0)).filterable)
+    if (!mRenderer->getRendererTextureCaps().get(getInternalFormat(0, 0)).filterable)
     {
         if (samplerState.magFilter != GL_NEAREST ||
             (samplerState.minFilter != GL_NEAREST && samplerState.minFilter != GL_NEAREST_MIPMAP_NEAREST))
@@ -1123,13 +1171,15 @@ void TextureD3D_Cube::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_Cube::getRenderTargetSerial(GLenum target, GLint level)
+unsigned int TextureD3D_Cube::getRenderTargetSerial(GLint level, GLint layer)
 {
+    GLenum target = gl::TextureCubeMap::layerIndexToTarget(layer);
     return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(target, level) : 0);
 }
 
-RenderTarget *TextureD3D_Cube::getRenderTarget(GLenum target, GLint level)
+RenderTarget *TextureD3D_Cube::getRenderTarget(GLint level, GLint layer)
 {
+    GLenum target = gl::TextureCubeMap::layerIndexToTarget(layer);
     ASSERT(gl::IsCubemapTextureTarget(target));
 
     // ensure the underlying texture is created
@@ -1138,10 +1188,10 @@ RenderTarget *TextureD3D_Cube::getRenderTarget(GLenum target, GLint level)
         return NULL;
     }
 
-    updateStorageFaceLevel(targetToIndex(target), level);
+    updateStorageFaceLevel(layer, level);
 
     // ensure this is NOT a depth texture
-    if (isDepth(target, level))
+    if (isDepth(level, layer))
     {
         return NULL;
     }
@@ -1149,8 +1199,9 @@ RenderTarget *TextureD3D_Cube::getRenderTarget(GLenum target, GLint level)
     return mTexStorage->getRenderTarget(target, level);
 }
 
-RenderTarget *TextureD3D_Cube::getDepthStencil(GLenum target, GLint level)
+RenderTarget *TextureD3D_Cube::getDepthStencil(GLint level, GLint layer)
 {
+    GLenum target = gl::TextureCubeMap::layerIndexToTarget(layer);
     ASSERT(gl::IsCubemapTextureTarget(target));
 
     // ensure the underlying texture is created
@@ -1159,10 +1210,10 @@ RenderTarget *TextureD3D_Cube::getDepthStencil(GLenum target, GLint level)
         return NULL;
     }
 
-    updateStorageFaceLevel(targetToIndex(target), level);
+    updateStorageFaceLevel(layer, level);
 
     // ensure this is a depth texture
-    if (!isDepth(target, level))
+    if (!isDepth(level, layer))
     {
         return NULL;
     }
@@ -1170,17 +1221,6 @@ RenderTarget *TextureD3D_Cube::getDepthStencil(GLenum target, GLint level)
     return mTexStorage->getRenderTarget(target, level);
 }
 
-int TextureD3D_Cube::targetToIndex(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);
-
-    return target - GL_TEXTURE_CUBE_MAP_POSITIVE_X;
-}
-
 void TextureD3D_Cube::initializeStorage(bool renderTarget)
 {
     // Only initialize the first time this texture is used as a render target or shader resource
@@ -1457,15 +1497,17 @@ TextureStorageInterface *TextureD3D_3D::getNativeTexture()
     return storage;
 }
 
-Image *TextureD3D_3D::getImage(int level) const
+Image *TextureD3D_3D::getImage(int level, int layer) const
 {
     ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
+    ASSERT(layer == 0);
     return mImageArray[level];
 }
 
-void TextureD3D_3D::setUsage(GLenum usage)
+GLsizei TextureD3D_3D::getLayerCount(int level) const
 {
-    mUsage = usage;
+    ASSERT(level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
+    return 1;
 }
 
 GLsizei TextureD3D_3D::getWidth(GLint level) const
@@ -1505,8 +1547,9 @@ bool TextureD3D_3D::isDepth(GLint level) const
     return gl::GetInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-void TextureD3D_3D::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_3D::setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_3D);
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, type);
 
     redefineImage(level, sizedInternalFormat, width, height, depth);
@@ -1535,16 +1578,20 @@ void TextureD3D_3D::setImage(GLint level, GLsizei width, GLsizei height, GLsizei
     }
 }
 
-void TextureD3D_3D::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
+void TextureD3D_3D::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_3D);
+
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
     redefineImage(level, format, width, height, depth);
 
     TextureD3D::setCompressedImage(imageSize, pixels, mImageArray[level]);
 }
 
-void TextureD3D_3D::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_3D::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_3D);
+
     bool fastUnpacked = false;
 
     // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer
@@ -1568,16 +1615,25 @@ void TextureD3D_3D::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zo
     }
 }
 
-void TextureD3D_3D::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
+void TextureD3D_3D::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_3D);
+
     if (TextureD3D::subImageCompressed(xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels, mImageArray[level]))
     {
         commitRect(level, xoffset, yoffset, zoffset, width, height, depth);
     }
 }
 
+void TextureD3D_3D::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
+{
+    UNIMPLEMENTED();
+}
+
 void TextureD3D_3D::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
+    ASSERT(target == GL_TEXTURE_3D);
+
     // can only make our texture storage to a render target if level 0 is defined (with a width & height) and
     // the current level we're copying to is defined (with appropriate format, width & height)
     bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0);
@@ -1608,8 +1664,10 @@ void TextureD3D_3D::copySubImage(GLenum target, GLint level, GLint xoffset, GLin
     }
 }
 
-void TextureD3D_3D::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
+void TextureD3D_3D::storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
+    ASSERT(target == GL_TEXTURE_3D);
+
     for (int level = 0; level < levels; level++)
     {
         GLsizei levelWidth = std::max(1, width >> level);
@@ -2018,11 +2076,6 @@ GLsizei TextureD3D_2DArray::getLayerCount(int level) const
     return mLayerCounts[level];
 }
 
-void TextureD3D_2DArray::setUsage(GLenum usage)
-{
-    mUsage = usage;
-}
-
 GLsizei TextureD3D_2DArray::getWidth(GLint level) const
 {
     return (level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS && mLayerCounts[level] > 0) ? mImageArray[level][0]->getWidth() : 0;
@@ -2048,8 +2101,10 @@ bool TextureD3D_2DArray::isDepth(GLint level) const
     return gl::GetInternalFormatInfo(getInternalFormat(level)).depthBits > 0;
 }
 
-void TextureD3D_2DArray::setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_2DArray::setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     GLenum sizedInternalFormat = gl::GetSizedInternalFormat(internalFormat, type);
 
     redefineImage(level, sizedInternalFormat, width, height, depth);
@@ -2064,8 +2119,10 @@ void TextureD3D_2DArray::setImage(GLint level, GLsizei width, GLsizei height, GL
     }
 }
 
-void TextureD3D_2DArray::setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
+void TextureD3D_2DArray::setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
     redefineImage(level, format, width, height, depth);
 
@@ -2079,8 +2136,10 @@ void TextureD3D_2DArray::setCompressedImage(GLint level, GLenum format, GLsizei
     }
 }
 
-void TextureD3D_2DArray::subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
+void TextureD3D_2DArray::subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(getInternalFormat(level));
     GLsizei inputDepthPitch = formatInfo.computeDepthPitch(type, width, height, unpack.alignment);
 
@@ -2096,8 +2155,10 @@ void TextureD3D_2DArray::subImage(GLint level, GLint xoffset, GLint yoffset, GLi
     }
 }
 
-void TextureD3D_2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
+void TextureD3D_2DArray::subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(format);
     GLsizei inputDepthPitch = formatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, width, height, 1);
 
@@ -2113,8 +2174,15 @@ void TextureD3D_2DArray::subImageCompressed(GLint level, GLint xoffset, GLint yo
     }
 }
 
+void TextureD3D_2DArray::copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
+{
+    UNIMPLEMENTED();
+}
+
 void TextureD3D_2DArray::copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     // can only make our texture storage to a render target if level 0 is defined (with a width & height) and
     // the current level we're copying to is defined (with appropriate format, width & height)
     bool canCreateRenderTarget = isLevelComplete(level) && isLevelComplete(0);
@@ -2144,8 +2212,10 @@ void TextureD3D_2DArray::copySubImage(GLenum target, GLint level, GLint xoffset,
     }
 }
 
-void TextureD3D_2DArray::storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
+void TextureD3D_2DArray::storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
+    ASSERT(target == GL_TEXTURE_2D_ARRAY);
+
     deleteImages();
 
     for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; level++)
diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.h b/src/libGLESv2/renderer/d3d/TextureD3D.h
index bdaca446..626316ab 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.h
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.h
@@ -32,22 +32,18 @@ class TextureStorageInterface2DArray;
 
 bool IsMipmapFiltered(const gl::SamplerState &samplerState);
 
-class TextureD3D : public TextureImpl
+class TextureD3D
 {
   public:
     TextureD3D(Renderer *renderer);
     virtual ~TextureD3D();
 
-    static TextureD3D *makeTextureD3D(TextureImpl *texture);
-
     GLint getBaseLevelWidth() const;
     GLint getBaseLevelHeight() const;
     GLint getBaseLevelDepth() const;
     GLenum getBaseLevelInternalFormat() const;
 
-    bool hasDirtyImages() const { return mDirtyImages; }
     bool isImmutable() const { return mImmutable; }
-    void resetDirty() { mDirtyImages = false; }
 
   protected:
     void setImage(const gl::PixelUnpackState &unpack, GLenum type, const void *pixels, Image *image);
@@ -88,9 +84,12 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
 
     virtual TextureStorageInterface *getNativeTexture();
 
-    virtual Image *getImage(int level) const;
+    virtual Image *getImage(int level, int layer) const;
+    virtual GLsizei getLayerCount(int level) const;
 
-    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty() { mDirtyImages = false; }
+    virtual void setUsage(GLenum usage) { mUsage = usage; }
 
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
@@ -98,13 +97,13 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
     GLenum getActualFormat(GLint level) const;
     bool isDepth(GLint level) const;
 
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
-    virtual void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
+    virtual void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+    virtual void storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
     virtual void bindTexImage(egl::Surface *surface);
@@ -112,10 +111,10 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
 
     virtual void generateMipmaps();
 
-    virtual unsigned int getRenderTargetSerial(GLint level);
+    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
-    virtual RenderTarget *getRenderTarget(GLint level);
-    virtual RenderTarget *getDepthSencil(GLint level);
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_2D);
@@ -135,7 +134,7 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
 
     void updateStorageLevel(int level);
 
-    virtual void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height);
+    void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height);
     void commitRect(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
 
     TextureStorageInterface2D *mTexStorage;
@@ -152,32 +151,33 @@ class TextureD3D_Cube : public TextureCubeImpl, public TextureD3D
 
     virtual TextureStorageInterface *getNativeTexture();
 
-    virtual Image *getImage(GLenum target, int level) const;
+    virtual Image *getImage(int level, int layer) const;
+    virtual GLsizei getLayerCount(int level) const;
 
-    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty() { mDirtyImages = false; }
+    virtual void setUsage(GLenum usage) { mUsage = usage; }
 
-    GLenum getInternalFormat(GLenum target, GLint level) const;
-    bool isDepth(GLenum target, GLint level) const;
+    GLenum getInternalFormat(GLint level, GLint layer) const;
+    bool isDepth(GLint level, GLint layer) const;
 
-    virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
-    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
     virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei size);
+    virtual void storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
     virtual bool isCubeComplete() const;
 
     virtual void generateMipmaps();
 
-    virtual unsigned int getRenderTargetSerial(GLenum target, GLint level);
-
-    virtual RenderTarget *getRenderTarget(GLenum target, GLint level);
-    virtual RenderTarget *getDepthStencil(GLenum target, GLint level);
+    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
 
-    static int targetToIndex(GLenum target);
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_Cube);
@@ -214,9 +214,12 @@ class TextureD3D_3D : public Texture3DImpl, public TextureD3D
 
     virtual TextureStorageInterface *getNativeTexture();
 
-    virtual Image *getImage(int level) const;
+    virtual Image *getImage(int level, int layer) const;
+    virtual GLsizei getLayerCount(int level) const;
 
-    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty() { mDirtyImages = false; }
+    virtual void setUsage(GLenum usage) { mUsage = usage; }
 
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
@@ -224,12 +227,13 @@ class TextureD3D_3D : public Texture3DImpl, public TextureD3D
     GLenum getInternalFormat(GLint level) const;
     bool isDepth(GLint level) const;
 
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+    virtual void storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
 
@@ -279,7 +283,9 @@ class TextureD3D_2DArray : public Texture2DArrayImpl, public TextureD3D
     virtual Image *getImage(int level, int layer) const;
     virtual GLsizei getLayerCount(int level) const;
 
-    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty() { mDirtyImages = false; }
+    virtual void setUsage(GLenum usage) { mUsage = usage; }
 
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
@@ -287,12 +293,13 @@ class TextureD3D_2DArray : public Texture2DArrayImpl, public TextureD3D
     GLenum getInternalFormat(GLint level) const;
     bool isDepth(GLint level) const;
 
-    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
-    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
-    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void setImage(GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
     virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
-    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+    virtual void storage(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
 
diff --git a/src/libGLESv2/renderer/d3d/TextureStorage.cpp b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
index 84658698..be82d33e 100644
--- a/src/libGLESv2/renderer/d3d/TextureStorage.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
@@ -117,7 +117,7 @@ void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
 
 unsigned int TextureStorageInterfaceCube::getRenderTargetSerial(GLenum target, GLint level) const
 {
-    return mFirstRenderTargetSerial + (level * 6) + TextureD3D_Cube::targetToIndex(target);
+    return mFirstRenderTargetSerial + (level * 6) + gl::TextureCubeMap::targetToLayerIndex(target);
 }
 
 TextureStorageInterface3D::TextureStorageInterface3D(Renderer *renderer, GLenum internalformat, bool renderTarget,
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
index 2d0f6b50..8baac11a 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
@@ -473,7 +473,9 @@ void Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *textur
 
     if (texture)
     {
-        TextureStorageInterface *texStorage = texture->getNativeTexture();
+        TextureImpl* textureImpl = texture->getImplementation();
+
+        TextureStorageInterface *texStorage = textureImpl->getNativeTexture();
         if (texStorage)
         {
             TextureStorage11 *storage11 = TextureStorage11::makeTextureStorage11(texStorage->getStorageInstance());
@@ -486,7 +488,6 @@ void Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *textur
         // missing the shader resource view
         ASSERT(textureSRV != NULL);
 
-        TextureD3D* textureImpl = TextureD3D::makeTextureD3D(texture->getImplementation());
         forceSetTexture = textureImpl->hasDirtyImages();
         textureImpl->resetDirty();
     }
diff --git a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
index cb54de19..fb29c3a5 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
@@ -778,7 +778,7 @@ RenderTarget *TextureStorage11_Cube::getRenderTargetFace(GLenum faceTarget, int
 {
     if (level >= 0 && level < getLevelCount())
     {
-        int faceIndex = TextureD3D_Cube::targetToIndex(faceTarget);
+        int faceIndex = gl::TextureCubeMap::targetToLayerIndex(faceTarget);
         if (!mRenderTarget[faceIndex][level])
         {
             ID3D11Device *device = mRenderer->getDevice();
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
index ae930b01..5959fca7 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
@@ -661,7 +661,9 @@ void Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture
 
     if (texture)
     {
-        TextureStorageInterface *texStorage = texture->getNativeTexture();
+        TextureImpl* textureImpl = texture->getImplementation();
+
+        TextureStorageInterface *texStorage = textureImpl->getNativeTexture();
         if (texStorage)
         {
             TextureStorage9 *storage9 = TextureStorage9::makeTextureStorage9(texStorage->getStorageInstance());
@@ -671,8 +673,6 @@ void Renderer9::setTexture(gl::SamplerType type, int index, gl::Texture *texture
         // in the texture class and we're unexpectedly missing the d3d texture
         ASSERT(d3dTexture != NULL);
 
-        TextureD3D* textureImpl = TextureD3D::makeTextureD3D(texture->getImplementation());
-
         serial = texture->getTextureSerial();
         forceSetTexture = textureImpl->hasDirtyImages();
         textureImpl->resetDirty();
diff --git a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
index a18228a7..9065bc60 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
@@ -266,7 +266,7 @@ IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, in
 
 RenderTarget *TextureStorage9_Cube::getRenderTargetFace(GLenum faceTarget, int level)
 {
-    return mRenderTarget[TextureD3D_Cube::targetToIndex(faceTarget)];
+    return mRenderTarget[gl::TextureCubeMap::targetToLayerIndex(faceTarget)];
 }
 
 void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)