Use ImageIndex in getRenderTarget.

Also change ImageIndex to allow invalid indexes for layer. In 3D
indexes, sometimes the layer parameter is invalid, indicating we
index an entire mip level instead of a layer of a mip level.

BUG=angle:741

Change-Id: I7b410f9aaf568f215bb93ae063934669a8fa09bd
Reviewed-on: https://chromium-review.googlesource.com/218312
Reviewed-by: Geoff Lang <geofflang@chromium.org>
Tested-by: Jamie Madill <jmadill@chromium.org>

9 files changed, 144 insertions, 167 deletions

diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.cpp b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
index 06803eaf..ae75cccf 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.cpp
@@ -244,7 +244,7 @@ Image *TextureD3D_2D::getImage(int level, int layer) const
 Image *TextureD3D_2D::getImage(const gl::ImageIndex &index) const
 {
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(index.layerIndex == 0);
+    ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_2D);
     return mImageArray[index.mipIndex];
 }
@@ -305,8 +305,10 @@ void TextureD3D_2D::setImage(GLenum target, GLint level, GLsizei width, GLsizei
     // Attempt a fast gpu copy of the pixel data to the surface
     if (isFastUnpackable(unpack, sizedInternalFormat) && isLevelComplete(level))
     {
+        gl::ImageIndex index = gl::ImageIndex::Make2D(level);
+
         // Will try to create RT storage if it does not exist
-        RenderTarget *destRenderTarget = getRenderTarget(level, 0);
+        RenderTarget *destRenderTarget = getRenderTarget(index);
         gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), 1);
 
         if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget))
@@ -340,9 +342,10 @@ void TextureD3D_2D::subImage(GLenum target, GLint level, GLint xoffset, GLint yo
 
     bool fastUnpacked = false;
 
+    gl::ImageIndex index = gl::ImageIndex::Make2D(level);
     if (isFastUnpackable(unpack, getInternalFormat(level)) && isLevelComplete(level))
     {
-        RenderTarget *renderTarget = getRenderTarget(level, 0);
+        RenderTarget *renderTarget = getRenderTarget(index);
         gl::Box destArea(xoffset, yoffset, 0, width, height, 1);
 
         if (renderTarget && fastUnpackPixels(unpack, pixels, destArea, getInternalFormat(level), type, renderTarget))
@@ -354,7 +357,6 @@ void TextureD3D_2D::subImage(GLenum target, GLint level, GLint xoffset, GLint yo
         }
     }
 
-    gl::ImageIndex index = gl::ImageIndex::Make2D(level);
     if (!fastUnpacked && TextureD3D::subImage(xoffset, yoffset, 0, width, height, 1, format, type, unpack, pixels, index))
     {
         commitRect(level, xoffset, yoffset, width, height);
@@ -513,15 +515,15 @@ void TextureD3D_2D::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_2D::getRenderTargetSerial(GLint level, GLint layer)
+unsigned int TextureD3D_2D::getRenderTargetSerial(const gl::ImageIndex &index)
 {
-    ASSERT(layer == 0);
-    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level) : 0);
+    ASSERT(!index.hasLayer());
+    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(index.mipIndex) : 0);
 }
 
-RenderTarget *TextureD3D_2D::getRenderTarget(GLint level, GLint layer)
+RenderTarget *TextureD3D_2D::getRenderTarget(const gl::ImageIndex &index)
 {
-    ASSERT(layer == 0);
+    ASSERT(!index.hasLayer());
 
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
@@ -529,8 +531,8 @@ RenderTarget *TextureD3D_2D::getRenderTarget(GLint level, GLint layer)
         return NULL;
     }
 
-    updateStorageLevel(level);
-    return mTexStorage->getRenderTarget(level);
+    updateStorageLevel(index.mipIndex);
+    return mTexStorage->getStorageInstance()->getRenderTarget(index);
 }
 
 bool TextureD3D_2D::isValidLevel(int level) const
@@ -1014,16 +1016,14 @@ void TextureD3D_Cube::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_Cube::getRenderTargetSerial(GLint level, GLint layer)
+unsigned int TextureD3D_Cube::getRenderTargetSerial(const gl::ImageIndex &index)
 {
-    GLenum target = gl::TextureCubeMap::layerIndexToTarget(layer);
-    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(target, level) : 0);
+    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(index.type, index.mipIndex) : 0);
 }
 
-RenderTarget *TextureD3D_Cube::getRenderTarget(GLint level, GLint layer)
+RenderTarget *TextureD3D_Cube::getRenderTarget(const gl::ImageIndex &index)
 {
-    GLenum target = gl::TextureCubeMap::layerIndexToTarget(layer);
-    ASSERT(gl::IsCubemapTextureTarget(target));
+    ASSERT(gl::IsCubemapTextureTarget(index.type));
 
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
@@ -1031,8 +1031,8 @@ RenderTarget *TextureD3D_Cube::getRenderTarget(GLint level, GLint layer)
         return NULL;
     }
 
-    updateStorageFaceLevel(layer, level);
-    return mTexStorage->getRenderTarget(target, level);
+    updateStorageFaceLevel(index.layerIndex, index.mipIndex);
+    return mTexStorage->getStorageInstance()->getRenderTarget(index);
 }
 
 void TextureD3D_Cube::initializeStorage(bool renderTarget)
@@ -1274,7 +1274,7 @@ Image *TextureD3D_3D::getImage(int level, int layer) const
 Image *TextureD3D_3D::getImage(const gl::ImageIndex &index) const
 {
     ASSERT(index.mipIndex < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS);
-    ASSERT(index.layerIndex == 0);
+    ASSERT(!index.hasLayer());
     ASSERT(index.type == GL_TEXTURE_3D);
     return mImageArray[index.mipIndex];
 }
@@ -1335,7 +1335,8 @@ void TextureD3D_3D::setImage(GLenum target, GLint level, GLsizei width, GLsizei
     if (isFastUnpackable(unpack, sizedInternalFormat))
     {
         // Will try to create RT storage if it does not exist
-        RenderTarget *destRenderTarget = getRenderTarget(level);
+        gl::ImageIndex index = gl::ImageIndex::Make3D(level);
+        RenderTarget *destRenderTarget = getRenderTarget(index);
         gl::Box destArea(0, 0, 0, getWidth(level), getHeight(level), getDepth(level));
 
         if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, sizedInternalFormat, type, destRenderTarget))
@@ -1369,10 +1370,12 @@ void TextureD3D_3D::subImage(GLenum target, GLint level, GLint xoffset, GLint yo
 
     bool fastUnpacked = false;
 
+    gl::ImageIndex index = gl::ImageIndex::Make3D(level);
+
     // Attempt a fast gpu copy of the pixel data to the surface if the app bound an unpack buffer
     if (isFastUnpackable(unpack, getInternalFormat(level)))
     {
-        RenderTarget *destRenderTarget = getRenderTarget(level);
+        RenderTarget *destRenderTarget = getRenderTarget(index);
         gl::Box destArea(xoffset, yoffset, zoffset, width, height, depth);
 
         if (destRenderTarget && fastUnpackPixels(unpack, pixels, destArea, getInternalFormat(level), type, destRenderTarget))
@@ -1384,7 +1387,6 @@ void TextureD3D_3D::subImage(GLenum target, GLint level, GLint xoffset, GLint yo
         }
     }
 
-    gl::ImageIndex index = gl::ImageIndex::Make3D(level);
     if (!fastUnpacked && TextureD3D::subImage(xoffset, yoffset, zoffset, width, height, depth, format, type, unpack, pixels, index))
     {
         commitRect(level, xoffset, yoffset, zoffset, width, height, depth);
@@ -1503,12 +1505,12 @@ void TextureD3D_3D::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_3D::getRenderTargetSerial(GLint level, GLint layer)
+unsigned int TextureD3D_3D::getRenderTargetSerial(const gl::ImageIndex &index)
 {
-    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0);
+    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(index.mipIndex, index.layerIndex) : 0);
 }
 
-RenderTarget *TextureD3D_3D::getRenderTarget(GLint level)
+RenderTarget *TextureD3D_3D::getRenderTarget(const gl::ImageIndex &index)
 {
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
@@ -1516,28 +1518,16 @@ RenderTarget *TextureD3D_3D::getRenderTarget(GLint level)
         return NULL;
     }
 
-    updateStorageLevel(level);
-
-    // ensure this is NOT a depth texture
-    if (isDepth(level))
+    if (index.hasLayer())
     {
-        return NULL;
+        updateStorage();
     }
-
-    return mTexStorage->getRenderTarget(level);
-}
-
-RenderTarget *TextureD3D_3D::getRenderTarget(GLint level, GLint layer)
-{
-    // ensure the underlying texture is created
-    if (!ensureRenderTarget())
+    else
     {
-        return NULL;
+        updateStorageLevel(index.mipIndex);
     }
 
-    updateStorage();
-
-    return mTexStorage->getRenderTarget(level, layer);
+    return mTexStorage->getStorageInstance()->getRenderTarget(index);
 }
 
 void TextureD3D_3D::initializeStorage(bool renderTarget)
@@ -2000,12 +1990,12 @@ void TextureD3D_2DArray::generateMipmaps()
     }
 }
 
-unsigned int TextureD3D_2DArray::getRenderTargetSerial(GLint level, GLint layer)
+unsigned int TextureD3D_2DArray::getRenderTargetSerial(const gl::ImageIndex &index)
 {
-    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(level, layer) : 0);
+    return (ensureRenderTarget() ? mTexStorage->getRenderTargetSerial(index.mipIndex, index.layerIndex) : 0);
 }
 
-RenderTarget *TextureD3D_2DArray::getRenderTarget(GLint level, GLint layer)
+RenderTarget *TextureD3D_2DArray::getRenderTarget(const gl::ImageIndex &index)
 {
     // ensure the underlying texture is created
     if (!ensureRenderTarget())
@@ -2013,8 +2003,8 @@ RenderTarget *TextureD3D_2DArray::getRenderTarget(GLint level, GLint layer)
         return NULL;
     }
 
-    updateStorageLevel(level);
-    return mTexStorage->getRenderTarget(level, layer);
+    updateStorageLevel(index.mipIndex);
+    return mTexStorage->getStorageInstance()->getRenderTarget(index);
 }
 
 void TextureD3D_2DArray::initializeStorage(bool renderTarget)
diff --git a/src/libGLESv2/renderer/d3d/TextureD3D.h b/src/libGLESv2/renderer/d3d/TextureD3D.h
index 1ede45e2..8777f360 100644
--- a/src/libGLESv2/renderer/d3d/TextureD3D.h
+++ b/src/libGLESv2/renderer/d3d/TextureD3D.h
@@ -52,8 +52,8 @@ class TextureD3D : public TextureImpl
 
     bool isImmutable() const { return mImmutable; }
 
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
+    virtual unsigned int getRenderTargetSerial(const gl::ImageIndex &index) = 0;
 
   protected:
     void setImage(const gl::PixelUnpackState &unpack, GLenum type, const void *pixels, Image *image);
@@ -116,8 +116,8 @@ class TextureD3D_2D : public TextureD3D
 
     virtual void generateMipmaps();
 
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
+    virtual unsigned int getRenderTargetSerial(const gl::ImageIndex &index);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_2D);
@@ -173,8 +173,8 @@ class TextureD3D_Cube : public TextureD3D
 
     virtual void generateMipmaps();
 
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
+    virtual unsigned int getRenderTargetSerial(const gl::ImageIndex &index);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_Cube);
@@ -230,9 +230,8 @@ class TextureD3D_3D : public TextureD3D
 
     virtual void generateMipmaps();
 
-    RenderTarget *getRenderTarget(GLint level);
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
+    virtual unsigned int getRenderTargetSerial(const gl::ImageIndex &index);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_3D);
@@ -287,8 +286,8 @@ class TextureD3D_2DArray : public TextureD3D
 
     virtual void generateMipmaps();
 
-    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
-    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
+    virtual unsigned int getRenderTargetSerial(const gl::ImageIndex &index);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureD3D_2DArray);
diff --git a/src/libGLESv2/renderer/d3d/TextureStorage.cpp b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
index 86902e90..f866472b 100644
--- a/src/libGLESv2/renderer/d3d/TextureStorage.cpp
+++ b/src/libGLESv2/renderer/d3d/TextureStorage.cpp
@@ -79,11 +79,6 @@ TextureStorageInterface2D::~TextureStorageInterface2D()
 {
 }
 
-RenderTarget *TextureStorageInterface2D::getRenderTarget(GLint level) const
-{
-    return mInstance->getRenderTarget(level);
-}
-
 void TextureStorageInterface2D::generateMipmap(int level)
 {
     mInstance->generateMipmap(level);
@@ -104,11 +99,6 @@ TextureStorageInterfaceCube::~TextureStorageInterfaceCube()
 {
 }
 
-RenderTarget *TextureStorageInterfaceCube::getRenderTarget(GLenum faceTarget, GLint level) const
-{
-    return mInstance->getRenderTargetFace(faceTarget, level);
-}
-
 void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
 {
     mInstance->generateMipmap(faceIndex, level);
@@ -136,16 +126,6 @@ void TextureStorageInterface3D::generateMipmap(int level)
     mInstance->generateMipmap(level);
 }
 
-RenderTarget *TextureStorageInterface3D::getRenderTarget(GLint level) const
-{
-    return mInstance->getRenderTarget(level);
-}
-
-RenderTarget *TextureStorageInterface3D::getRenderTarget(GLint level, GLint layer) const
-{
-    return mInstance->getRenderTargetLayer(level, layer);
-}
-
 unsigned int TextureStorageInterface3D::getRenderTargetSerial(GLint level, GLint layer) const
 {
     return mFirstRenderTargetSerial + static_cast<unsigned int>((layer * mInstance->getLevelCount()) + level);
@@ -167,11 +147,6 @@ void TextureStorageInterface2DArray::generateMipmap(int level)
     mInstance->generateMipmap(level);
 }
 
-RenderTarget *TextureStorageInterface2DArray::getRenderTarget(GLint level, GLint layer) const
-{
-    return mInstance->getRenderTargetLayer(level, layer);
-}
-
 unsigned int TextureStorageInterface2DArray::getRenderTargetSerial(GLint level, GLint layer) const
 {
     return mFirstRenderTargetSerial + static_cast<unsigned int>((layer * mInstance->getLevelCount()) + level);
diff --git a/src/libGLESv2/renderer/d3d/TextureStorage.h b/src/libGLESv2/renderer/d3d/TextureStorage.h
index c42d4b68..d16ee48e 100644
--- a/src/libGLESv2/renderer/d3d/TextureStorage.h
+++ b/src/libGLESv2/renderer/d3d/TextureStorage.h
@@ -15,6 +15,11 @@
 
 #include <GLES2/gl2.h>
 
+namespace gl
+{
+struct ImageIndex;
+}
+
 namespace rx
 {
 class Renderer;
@@ -32,9 +37,7 @@ class TextureStorage
     virtual bool isManaged() const = 0;
     virtual int getLevelCount() const = 0;
 
-    virtual RenderTarget *getRenderTarget(int level) = 0;
-    virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level) = 0;
-    virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer) = 0;
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
     virtual void generateMipmap(int level) = 0;
     virtual void generateMipmap(int face, int level) = 0;
 
@@ -78,7 +81,6 @@ class TextureStorageInterface2D : public TextureStorageInterface
     virtual ~TextureStorageInterface2D();
 
     void generateMipmap(int level);
-    RenderTarget *getRenderTarget(GLint level) const;
 
     unsigned int getRenderTargetSerial(GLint level) const;
 
@@ -95,7 +97,6 @@ class TextureStorageInterfaceCube : public TextureStorageInterface
     virtual ~TextureStorageInterfaceCube();
 
     void generateMipmap(int faceIndex, int level);
-    RenderTarget *getRenderTarget(GLenum faceTarget, GLint level) const;
 
     virtual unsigned int getRenderTargetSerial(GLenum target, GLint level) const;
 
@@ -113,8 +114,6 @@ class TextureStorageInterface3D : public TextureStorageInterface
     virtual ~TextureStorageInterface3D();
 
     void generateMipmap(int level);
-    RenderTarget *getRenderTarget(GLint level) const;
-    RenderTarget *getRenderTarget(GLint level, GLint layer) const;
 
     virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) const;
 
@@ -132,7 +131,6 @@ class TextureStorageInterface2DArray : public TextureStorageInterface
     virtual ~TextureStorageInterface2DArray();
 
     void generateMipmap(int level);
-    RenderTarget *getRenderTarget(GLint level, GLint layer) const;
 
     virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) const;
 
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
index eb13343b..d7cadf6c 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
@@ -1958,7 +1958,8 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(level));
+    gl::ImageIndex index = gl::ImageIndex::Make2D(level);
+    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(index));
     if (!destRenderTarget)
     {
         ERR("Failed to retrieve the render target from the destination storage.");
@@ -2019,7 +2020,8 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetFace(target, level));
+    gl::ImageIndex index = gl::ImageIndex::MakeCube(target, level);
+    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(index));
     if (!destRenderTarget)
     {
         ERR("Failed to retrieve the render target from the destination storage.");
@@ -2080,7 +2082,8 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetLayer(level, zOffset));
+    gl::ImageIndex index = gl::ImageIndex::Make3D(level, zOffset);
+    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(index));
     if (!destRenderTarget)
     {
         ERR("Failed to retrieve the render target from the destination storage.");
@@ -2142,7 +2145,8 @@ bool Renderer11::copyImage(gl::Framebuffer *framebuffer, const gl::Rectangle &so
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTargetLayer(level, zOffset));
+    gl::ImageIndex index = gl::ImageIndex::Make2DArray(level, zOffset);
+    RenderTarget11 *destRenderTarget = RenderTarget11::makeRenderTarget11(storage11->getRenderTarget(index));
     if (!destRenderTarget)
     {
         SafeRelease(source);
diff --git a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
index 10a5e7e5..9b630d7e 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp
@@ -17,6 +17,7 @@
 #include "libGLESv2/renderer/d3d/d3d11/Image11.h"
 #include "libGLESv2/renderer/d3d/TextureD3D.h"
 #include "libGLESv2/main.h"
+#include "libGLESv2/ImageIndex.h"
 
 #include "common/utilities.h"
 
@@ -605,8 +606,12 @@ ID3D11Resource *TextureStorage11_2D::getResource() const
     return mTexture;
 }
 
-RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
+RenderTarget *TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index)
 {
+    ASSERT(!index.hasLayer());
+
+    int level = index.mipIndex;
+
     if (level >= 0 && level < getLevelCount())
     {
         if (!mRenderTarget[level])
@@ -705,8 +710,11 @@ void TextureStorage11_2D::generateMipmap(int level)
 {
     invalidateSwizzleCacheLevel(level);
 
-    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(level - 1));
-    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(level));
+    gl::ImageIndex srcIndex = gl::ImageIndex::Make2D(level - 1);
+    gl::ImageIndex destIndex = gl::ImageIndex::Make2D(level);
+
+    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
     generateMipmapLayer(source, dest);
 }
@@ -971,11 +979,13 @@ ID3D11Resource *TextureStorage11_Cube::getResource() const
     return mTexture;
 }
 
-RenderTarget *TextureStorage11_Cube::getRenderTargetFace(GLenum faceTarget, int level)
+RenderTarget *TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index)
 {
+    int faceIndex = index.layerIndex;
+    int level = index.mipIndex;
+
     if (level >= 0 && level < getLevelCount())
     {
-        int faceIndex = gl::TextureCubeMap::targetToLayerIndex(faceTarget);
         if (!mRenderTarget[faceIndex][level])
         {
             ID3D11Device *device = mRenderer->getDevice();
@@ -1103,8 +1113,11 @@ void TextureStorage11_Cube::generateMipmap(int faceIndex, int level)
 {
     invalidateSwizzleCacheLevel(level);
 
-    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTargetFace(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level - 1));
-    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTargetFace(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level));
+    gl::ImageIndex srcIndex = gl::ImageIndex::MakeCube(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level - 1);
+    gl::ImageIndex destIndex = gl::ImageIndex::MakeCube(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level);
+
+    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
     generateMipmapLayer(source, dest);
 }
@@ -1380,20 +1393,24 @@ ID3D11ShaderResourceView *TextureStorage11_3D::createSRV(int baseLevel, int mipL
     return SRV;
 }
 
-RenderTarget *TextureStorage11_3D::getRenderTarget(int mipLevel)
+RenderTarget *TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index)
 {
+    int mipLevel = index.mipIndex;
+
     if (mipLevel >= 0 && mipLevel < getLevelCount())
     {
-        if (!mLevelRenderTargets[mipLevel])
+        ASSERT(mRenderTargetFormat != DXGI_FORMAT_UNKNOWN);
+
+        if (!index.hasLayer())
         {
-            ID3D11ShaderResourceView *srv = getSRVLevel(mipLevel);
-            if (!srv)
+            if (!mLevelRenderTargets[mipLevel])
             {
-                return NULL;
-            }
+                ID3D11ShaderResourceView *srv = getSRVLevel(mipLevel);
+                if (!srv)
+                {
+                    return NULL;
+                }
 
-            if (mRenderTargetFormat != DXGI_FORMAT_UNKNOWN)
-            {
                 ID3D11Device *device = mRenderer->getDevice();
 
                 D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
@@ -1418,35 +1435,22 @@ RenderTarget *TextureStorage11_3D::getRenderTarget(int mipLevel)
                 // RenderTarget will take ownership of these resources
                 SafeRelease(rtv);
             }
-            else
-            {
-                UNREACHABLE();
-            }
-        }
-
-        return mLevelRenderTargets[mipLevel];
-    }
-    else
-    {
-        return NULL;
-    }
-}
 
-RenderTarget *TextureStorage11_3D::getRenderTargetLayer(int mipLevel, int layer)
-{
-    if (mipLevel >= 0 && mipLevel < getLevelCount())
-    {
-        LevelLayerKey key(mipLevel, layer);
-        if (mLevelLayerRenderTargets.find(key) == mLevelLayerRenderTargets.end())
+            return mLevelRenderTargets[mipLevel];
+        }
+        else
         {
-            ID3D11Device *device = mRenderer->getDevice();
-            HRESULT result;
-
-            // TODO, what kind of SRV is expected here?
-            ID3D11ShaderResourceView *srv = NULL;
+            int layer = index.layerIndex;
 
-            if (mRenderTargetFormat != DXGI_FORMAT_UNKNOWN)
+            LevelLayerKey key(mipLevel, layer);
+            if (mLevelLayerRenderTargets.find(key) == mLevelLayerRenderTargets.end())
             {
+                ID3D11Device *device = mRenderer->getDevice();
+                HRESULT result;
+
+                // TODO, what kind of SRV is expected here?
+                ID3D11ShaderResourceView *srv = NULL;
+
                 D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
                 rtvDesc.Format = mRenderTargetFormat;
                 rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
@@ -1470,26 +1474,23 @@ RenderTarget *TextureStorage11_3D::getRenderTargetLayer(int mipLevel, int layer)
                 SafeRelease(rtv);
                 SafeRelease(srv);
             }
-            else
-            {
-                UNREACHABLE();
-            }
-        }
 
-        return mLevelLayerRenderTargets[key];
-    }
-    else
-    {
-        return NULL;
+            return mLevelLayerRenderTargets[key];
+        }
     }
+
+    return NULL;
 }
 
 void TextureStorage11_3D::generateMipmap(int level)
 {
     invalidateSwizzleCacheLevel(level);
 
-    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(level - 1));
-    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(level));
+    gl::ImageIndex srcIndex = gl::ImageIndex::Make3D(level - 1);
+    gl::ImageIndex destIndex = gl::ImageIndex::Make3D(level);
+
+    RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+    RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
     generateMipmapLayer(source, dest);
 }
@@ -1760,8 +1761,13 @@ ID3D11ShaderResourceView *TextureStorage11_2DArray::createSRV(int baseLevel, int
     return SRV;
 }
 
-RenderTarget *TextureStorage11_2DArray::getRenderTargetLayer(int mipLevel, int layer)
+RenderTarget *TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index)
 {
+    ASSERT(index.hasLayer());
+
+    int mipLevel = index.mipIndex;
+    int layer = index.layerIndex;
+
     if (mipLevel >= 0 && mipLevel < getLevelCount())
     {
         LevelLayerKey key(mipLevel, layer);
@@ -1831,8 +1837,11 @@ void TextureStorage11_2DArray::generateMipmap(int level)
     invalidateSwizzleCacheLevel(level);
     for (unsigned int layer = 0; layer < mTextureDepth; layer++)
     {
-        RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTargetLayer(level - 1, layer));
-        RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTargetLayer(level, layer));
+        gl::ImageIndex sourceIndex = gl::ImageIndex::Make2DArray(level - 1, layer);
+        gl::ImageIndex destIndex = gl::ImageIndex::Make2DArray(level, layer);
+
+        RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(sourceIndex));
+        RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
         generateMipmapLayer(source, dest);
     }
diff --git a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
index 76eeada5..133790b2 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
+++ b/src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h
@@ -15,6 +15,11 @@
 
 #include <map>
 
+namespace gl
+{
+struct ImageIndex;
+}
+
 namespace rx
 {
 class RenderTarget;
@@ -37,9 +42,7 @@ class TextureStorage11 : public TextureStorage
 
     virtual ID3D11Resource *getResource() const = 0;
     virtual ID3D11ShaderResourceView *getSRV(const gl::SamplerState &samplerState);
-    virtual RenderTarget *getRenderTarget(int level) { return NULL; }
-    virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level) { return NULL; }
-    virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer) { return NULL; }
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
 
     virtual void generateMipmap(int level) {};
     virtual void generateMipmap(int face, int level) {};
@@ -160,7 +163,7 @@ class TextureStorage11_2D : public TextureStorage11
     static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
 
     virtual ID3D11Resource *getResource() const;
-    virtual RenderTarget *getRenderTarget(int level);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
     virtual void generateMipmap(int level);
 
@@ -198,7 +201,7 @@ class TextureStorage11_Cube : public TextureStorage11
     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
 
     virtual ID3D11Resource *getResource() const;
-    virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
     virtual void generateMipmap(int faceIndex, int level);
 
@@ -237,8 +240,9 @@ class TextureStorage11_3D : public TextureStorage11
     static TextureStorage11_3D *makeTextureStorage11_3D(TextureStorage *storage);
 
     virtual ID3D11Resource *getResource() const;
-    virtual RenderTarget *getRenderTarget(int mipLevel);
-    virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
+
+    // Handles both layer and non-layer RTs
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
     virtual void generateMipmap(int level);
 
@@ -281,7 +285,7 @@ class TextureStorage11_2DArray : public TextureStorage11
     static TextureStorage11_2DArray *makeTextureStorage11_2DArray(TextureStorage *storage);
 
     virtual ID3D11Resource *getResource() const;
-    virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
     virtual void generateMipmap(int level);
 
diff --git a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
index 5b658235..b328369e 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp
@@ -157,7 +157,7 @@ IDirect3DSurface9 *TextureStorage9_2D::getSurfaceLevel(int level, bool dirty)
     return surface;
 }
 
-RenderTarget *TextureStorage9_2D::getRenderTarget(int level)
+RenderTarget *TextureStorage9_2D::getRenderTarget(const gl::ImageIndex &/*index*/)
 {
     return mRenderTarget;
 }
@@ -263,9 +263,9 @@ IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, in
     return surface;
 }
 
-RenderTarget *TextureStorage9_Cube::getRenderTargetFace(GLenum faceTarget, int level)
+RenderTarget *TextureStorage9_Cube::getRenderTarget(const gl::ImageIndex &index)
 {
-    return mRenderTarget[gl::TextureCubeMap::targetToLayerIndex(faceTarget)];
+    return mRenderTarget[index.layerIndex];
 }
 
 void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)
diff --git a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h
index cc7c155d..11cbdf4d 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h
+++ b/src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h
@@ -34,9 +34,7 @@ class TextureStorage9 : public TextureStorage
     DWORD getUsage() const;
 
     virtual IDirect3DBaseTexture9 *getBaseTexture() const = 0;
-    virtual RenderTarget *getRenderTarget(int level) { return NULL; }
-    virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level) { return NULL; }
-    virtual RenderTarget *getRenderTargetLayer(int mipLevel, int layer) { return NULL; }
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
     virtual void generateMipmap(int level) {};
     virtual void generateMipmap(int face, int level) {};
 
@@ -68,7 +66,7 @@ class TextureStorage9_2D : public TextureStorage9
     static TextureStorage9_2D *makeTextureStorage9_2D(TextureStorage *storage);
 
     IDirect3DSurface9 *getSurfaceLevel(int level, bool dirty);
-    virtual RenderTarget *getRenderTarget(int level);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
     virtual void generateMipmap(int level);
 
@@ -90,7 +88,7 @@ class TextureStorage9_Cube : public TextureStorage9
     static TextureStorage9_Cube *makeTextureStorage9_Cube(TextureStorage *storage);
 
     IDirect3DSurface9 *getCubeMapSurface(GLenum faceTarget, int level, bool dirty);
-    virtual RenderTarget *getRenderTargetFace(GLenum faceTarget, int level);
+    virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
     virtual void generateMipmap(int faceIndex, int level);