Added 3D texture classes for TextureStorage and TextureStorageInterface.

src/libGLESv2/renderer/Image.h

@@ -23,6 +23,7 @@ namespace rx
 class Renderer;
 class TextureStorageInterface2D;
 class TextureStorageInterfaceCube;
+class TextureStorageInterface3D;
 
 class Image
 {
@@ -42,8 +43,10 @@ class Image
 
     virtual void setManagedSurface(TextureStorageInterface2D *storage, int level) {};
     virtual void setManagedSurface(TextureStorageInterfaceCube *storage, int face, int level) {};
+    virtual void setManagedSurface(TextureStorageInterface3D *storage, int level) {};
     virtual bool updateSurface(TextureStorageInterface2D *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
     virtual bool updateSurface(TextureStorageInterfaceCube *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height) = 0;
+    virtual bool updateSurface(TextureStorageInterface3D *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) = 0;
 
     virtual bool redefine(Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease) = 0;
 

src/libGLESv2/renderer/Image11.cpp

@@ -114,13 +114,19 @@ bool Image11::isDirty() const
 bool Image11::updateSurface(TextureStorageInterface2D *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
     TextureStorage11_2D *storage11 = TextureStorage11_2D::makeTextureStorage11_2D(storage->getStorageInstance());
-    return storage11->updateSubresourceLevel(getStagingTexture(), getStagingSubresource(), level, 0, xoffset, yoffset, width, height);
+    return storage11->updateSubresourceLevel(getStagingTexture(), getStagingSubresource(), level, 0, xoffset, yoffset, 0, width, height, 1);
 }
 
 bool Image11::updateSurface(TextureStorageInterfaceCube *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
     TextureStorage11_Cube *storage11 = TextureStorage11_Cube::makeTextureStorage11_Cube(storage->getStorageInstance());
-    return storage11->updateSubresourceLevel(getStagingTexture(), getStagingSubresource(), level, face, xoffset, yoffset, width, height);
+    return storage11->updateSubresourceLevel(getStagingTexture(), getStagingSubresource(), level, face, xoffset, yoffset, 0, width, height, 1);
+}
+
+bool Image11::updateSurface(TextureStorageInterface3D *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
+{
+    UNIMPLEMENTED();
+    return false;
 }
 
 bool Image11::redefine(Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease)

src/libGLESv2/renderer/Image11.h

@@ -40,6 +40,7 @@ class Image11 : public Image
 
     virtual bool updateSurface(TextureStorageInterface2D *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
     virtual bool updateSurface(TextureStorageInterfaceCube *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool updateSurface(TextureStorageInterface3D *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual bool redefine(Renderer *renderer, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, bool forceRelease);
 

src/libGLESv2/renderer/Image9.cpp

@@ -307,6 +307,13 @@ bool Image9::updateSurface(TextureStorageInterfaceCube *storage, int face, int l
     return updateSurface(storage9->getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level, true), xoffset, yoffset, width, height);
 }
 
+bool Image9::updateSurface(TextureStorageInterface3D *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
+{
+    // 3D textures are not supported by the D3D9 backend.
+    UNREACHABLE();
+    return false;
+}
+
 bool Image9::updateSurface(IDirect3DSurface9 *destSurface, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height)
 {
     if (!destSurface)

src/libGLESv2/renderer/Image9.h

@@ -49,6 +49,7 @@ class Image9 : public Image
     virtual void setManagedSurface(TextureStorageInterfaceCube *storage, int face, int level);
     virtual bool updateSurface(TextureStorageInterface2D *storage, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
     virtual bool updateSurface(TextureStorageInterfaceCube *storage, int face, int level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    virtual bool updateSurface(TextureStorageInterface3D *storage, int level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
 
     virtual void loadData(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
                           GLint unpackAlignment, const void *input);

src/libGLESv2/renderer/Renderer.h

@@ -215,6 +215,7 @@ class Renderer
     virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain) = 0;
     virtual TextureStorage *createTextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height) = 0;
     virtual TextureStorage *createTextureStorageCube(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size) = 0;
+    virtual TextureStorage *createTextureStorage3D(int levels, GLenum internalformat, GLenum usage, GLsizei width, GLsizei height, GLsizei depth) = 0;
 
     // Buffer creation
     virtual VertexBuffer *createVertexBuffer() = 0;

src/libGLESv2/renderer/Renderer11.cpp

@@ -3086,6 +3086,11 @@ TextureStorage *Renderer11::createTextureStorageCube(int levels, GLenum internal
     return new TextureStorage11_Cube(this, levels, internalformat, usage, forceRenderable, size);
 }
 
+TextureStorage *Renderer11::createTextureStorage3D(int levels, GLenum internalformat, GLenum usage, GLsizei width, GLsizei height, GLsizei depth)
+{
+    return new TextureStorage11_3D(this, levels, internalformat, usage, width, height, depth);
+}
+
 static inline unsigned int getFastPixelCopySize(DXGI_FORMAT sourceFormat, GLenum destFormat, GLenum destType)
 {
     if (sourceFormat == DXGI_FORMAT_A8_UNORM &&

src/libGLESv2/renderer/Renderer11.h

@@ -166,6 +166,7 @@ class Renderer11 : public Renderer
     virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain);
     virtual TextureStorage *createTextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
     virtual TextureStorage *createTextureStorageCube(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
+    virtual TextureStorage *createTextureStorage3D(int levels, GLenum internalformat, GLenum usage, GLsizei width, GLsizei height, GLsizei depth);
 
     // Buffer creation
     virtual VertexBuffer *createVertexBuffer();

src/libGLESv2/renderer/Renderer9.cpp

@@ -3207,4 +3207,12 @@ TextureStorage *Renderer9::createTextureStorageCube(int levels, GLenum internalf
     return new TextureStorage9_Cube(this, levels, internalformat, usage, forceRenderable, size);
 }
 
+TextureStorage *Renderer9::createTextureStorage3D(int levels, GLenum internalformat, GLenum usage, GLsizei width, GLsizei height, GLsizei depth)
+{
+    // 3D textures are not supported by the D3D9 backend.
+    UNREACHABLE();
+
+    return NULL;
+}
+
 }

src/libGLESv2/renderer/Renderer9.h

@@ -181,6 +181,7 @@ class Renderer9 : public Renderer
     virtual TextureStorage *createTextureStorage2D(SwapChain *swapChain);
     virtual TextureStorage *createTextureStorage2D(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height);
     virtual TextureStorage *createTextureStorageCube(int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size);
+    virtual TextureStorage *createTextureStorage3D(int levels, GLenum internalformat, GLenum usage, GLsizei width, GLsizei height, GLsizei depth);
 
     // Buffer creation
     virtual VertexBuffer *createVertexBuffer();

src/libGLESv2/renderer/TextureStorage.cpp

@@ -36,7 +36,6 @@ bool TextureStorageInterface::isRenderTarget() const
     return mInstance->isRenderTarget();
 }
 
-
 bool TextureStorageInterface::isManaged() const
 {
     return mInstance->isManaged();
@@ -57,7 +56,6 @@ int TextureStorageInterface::getLodOffset() const
     return mInstance->getLodOffset();
 }
 
-
 int TextureStorageInterface::levelCount()
 {
     return mInstance->levelCount();
@@ -119,4 +117,25 @@ unsigned int TextureStorageInterfaceCube::getRenderTargetSerial(GLenum target) c
     return mFirstRenderTargetSerial + gl::TextureCubeMap::faceIndex(target);
 }
 
+TextureStorageInterface3D::TextureStorageInterface3D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
+                                                     GLsizei width, GLsizei height, GLsizei depth)
+{
+    mInstance = renderer->createTextureStorage3D(levels, internalformat, usage, width, height, depth);
+}
+
+TextureStorageInterface3D::~TextureStorageInterface3D()
+{
+}
+
+void TextureStorageInterface3D::generateMipmap(int level)
+{
+    mInstance->generateMipmap(level);
+}
+
+unsigned int TextureStorageInterface3D::getRenderTargetSerial(GLenum target) const
+{
+    // TODO: 3D render targets not supported yet.
+    return 0;
+}
+
 }

src/libGLESv2/renderer/TextureStorage.h

@@ -104,7 +104,21 @@ class TextureStorageInterfaceCube : public TextureStorageInterface
     const unsigned int mFirstRenderTargetSerial;
 };
 
+class TextureStorageInterface3D : public TextureStorageInterface
+{
+  public:
+    TextureStorageInterface3D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
+                              GLsizei width, GLsizei height, GLsizei depth);
+    virtual ~TextureStorageInterface3D();
+
+    void generateMipmap(int level);
+
+    virtual unsigned int getRenderTargetSerial(GLenum target) const;
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureStorageInterface3D);
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTURESTORAGE_H_
-

src/libGLESv2/renderer/TextureStorage11.cpp

@@ -25,14 +25,14 @@ TextureStorage11::TextureStorage11(Renderer *renderer, UINT bindFlags)
     : mBindFlags(bindFlags),
       mLodOffset(0),
       mMipLevels(0),
-      mTexture(NULL),
       mTextureFormat(DXGI_FORMAT_UNKNOWN),
       mShaderResourceFormat(DXGI_FORMAT_UNKNOWN),
       mRenderTargetFormat(DXGI_FORMAT_UNKNOWN),
       mDepthStencilFormat(DXGI_FORMAT_UNKNOWN),
       mSRV(NULL),
       mTextureWidth(0),
-      mTextureHeight(0)
+      mTextureHeight(0),
+      mTextureDepth(0)
 {
     mRenderer = Renderer11::makeRenderer11(renderer);
 }
@@ -91,12 +91,6 @@ UINT TextureStorage11::getBindFlags() const
 {
     return mBindFlags;
 }
-
-ID3D11Texture2D *TextureStorage11::getBaseTexture() const
-{
-    return mTexture;
-}
-
 int TextureStorage11::getLodOffset() const
 {
     return mLodOffset;
@@ -132,9 +126,9 @@ UINT TextureStorage11::getSubresourceIndex(int level, int faceIndex)
     return index;
 }
 
-bool TextureStorage11::updateSubresourceLevel(ID3D11Texture2D *srcTexture, unsigned int sourceSubresource,
-                                              int level, int face, GLint xoffset, GLint yoffset,
-                                              GLsizei width, GLsizei height)
+bool TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture, unsigned int sourceSubresource,
+                                              int level, int face, GLint xoffset, GLint yoffset, GLint zoffset,
+                                              GLsizei width, GLsizei height, GLsizei depth)
 {
     if (srcTexture)
     {
@@ -148,14 +142,14 @@ bool TextureStorage11::updateSubresourceLevel(ID3D11Texture2D *srcTexture, unsig
         srcBox.top = yoffset;
         srcBox.right = xoffset + width;
         srcBox.bottom = yoffset + height;
-        srcBox.front = 0;
-        srcBox.back = 1;
+        srcBox.front = zoffset;
+        srcBox.back = zoffset + depth;
 
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
 
         ASSERT(getBaseTexture());
         context->CopySubresourceRegion(getBaseTexture(), getSubresourceIndex(level + mLodOffset, face),
-                                       xoffset, yoffset, 0, srcTexture, sourceSubresource, &srcBox);
+                                       xoffset, yoffset, zoffset, srcTexture, sourceSubresource, &srcBox);
         return true;
     }
 
@@ -216,6 +210,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
     mTextureFormat = texDesc.Format;
     mTextureWidth = texDesc.Width;
     mTextureHeight = texDesc.Height;
+    mTextureDepth = 1;
 
     D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
     mSRV->GetDesc(&srvDesc);
@@ -233,6 +228,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
     : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
 {
+    mTexture = NULL;
     for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
         mRenderTarget[i] = NULL;
@@ -296,6 +292,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum
             mMipLevels = desc.MipLevels;
             mTextureWidth = desc.Width;
             mTextureHeight = desc.Height;
+            mTextureDepth = 1;
         }
     }
 }
@@ -327,6 +324,11 @@ TextureStorage11_2D *TextureStorage11_2D::makeTextureStorage11_2D(TextureStorage
     return static_cast<TextureStorage11_2D*>(storage);
 }
 
+ID3D11Resource *TextureStorage11_2D::getBaseTexture() const
+{
+    return mTexture;
+}
+
 RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
 {
     if (level >= 0 && level < static_cast<int>(mMipLevels))
@@ -451,6 +453,7 @@ void TextureStorage11_2D::generateMipmap(int level)
 TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
     : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, forceRenderable))
 {
+    mTexture = NULL;
     for (unsigned int i = 0; i < 6; i++)
     {
         for (unsigned int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; j++)
@@ -512,6 +515,7 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLe
             mMipLevels = desc.MipLevels;
             mTextureWidth = desc.Width;
             mTextureHeight = desc.Height;
+            mTextureDepth = 1;
         }
     }
 }
@@ -546,6 +550,11 @@ TextureStorage11_Cube *TextureStorage11_Cube::makeTextureStorage11_Cube(TextureS
     return static_cast<TextureStorage11_Cube*>(storage);
 }
 
+ID3D11Resource *TextureStorage11_Cube::getBaseTexture() const
+{
+    return mTexture;
+}
+
 RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int level)
 {
     unsigned int faceIdx = gl::TextureCubeMap::faceIndex(faceTarget);
@@ -673,4 +682,118 @@ void TextureStorage11_Cube::generateMipmap(int face, int level)
     generateMipmapLayer(source, dest);
 }
 
+TextureStorage11_3D::TextureStorage11_3D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
+                                         GLsizei width, GLsizei height, GLsizei depth)
+    : TextureStorage11(renderer, GetTextureBindFlags(gl_d3d11::ConvertTextureFormat(internalformat), usage, false))
+{
+    mTexture = NULL;
+
+    DXGI_FORMAT convertedFormat = gl_d3d11::ConvertTextureFormat(internalformat);
+    ASSERT(!d3d11::IsDepthStencilFormat(convertedFormat));
+
+    mTextureFormat = convertedFormat;
+    mShaderResourceFormat = convertedFormat;
+    mDepthStencilFormat = DXGI_FORMAT_UNKNOWN;
+    mRenderTargetFormat = convertedFormat;
+
+    // If the width, height or depth are not positive this should be treated as an incomplete texture
+    // we handle that here by skipping the d3d texture creation
+    if (width > 0 && height > 0 && depth > 0)
+    {
+        // adjust size if needed for compressed textures
+        gl::MakeValidSize(false, gl::IsCompressed(internalformat), &width, &height, &mLodOffset);
+
+        ID3D11Device *device = mRenderer->getDevice();
+
+        D3D11_TEXTURE3D_DESC desc;
+        desc.Width = width;
+        desc.Height = height;
+        desc.Depth = depth;
+        desc.MipLevels = (levels > 0) ? levels + mLodOffset : 0;
+        desc.Format = mTextureFormat;
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.BindFlags = getBindFlags();
+        desc.CPUAccessFlags = 0;
+        desc.MiscFlags = 0;
+
+        HRESULT result = device->CreateTexture3D(&desc, NULL, &mTexture);
+
+        // this can happen from windows TDR
+        if (d3d11::isDeviceLostError(result))
+        {
+            mRenderer->notifyDeviceLost();
+            gl::error(GL_OUT_OF_MEMORY);
+        }
+        else if (FAILED(result))
+        {
+            ASSERT(result == E_OUTOFMEMORY);
+            ERR("Creating image failed.");
+            gl::error(GL_OUT_OF_MEMORY);
+        }
+        else
+        {
+            mTexture->GetDesc(&desc);
+            mMipLevels = desc.MipLevels;
+            mTextureWidth = desc.Width;
+            mTextureHeight = desc.Height;
+            mTextureDepth = desc.Depth;
+        }
+    }
+}
+
+TextureStorage11_3D::~TextureStorage11_3D()
+{
+    if (mTexture)
+    {
+        mTexture->Release();
+        mTexture = NULL;
+    }
+
+    if (mSRV)
+    {
+        mSRV->Release();
+        mSRV = NULL;
+    }
+}
+
+TextureStorage11_3D *TextureStorage11_3D::makeTextureStorage11_3D(TextureStorage *storage)
+{
+    ASSERT(HAS_DYNAMIC_TYPE(TextureStorage11_3D*, storage));
+    return static_cast<TextureStorage11_3D*>(storage);
+}
+
+ID3D11Resource *TextureStorage11_3D::getBaseTexture() const
+{
+    return mTexture;
+}
+
+ID3D11ShaderResourceView *TextureStorage11_3D::getSRV()
+{
+    if (!mSRV)
+    {
+        ID3D11Device *device = mRenderer->getDevice();
+
+        D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
+        srvDesc.Format = mShaderResourceFormat;
+        srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
+        srvDesc.Texture3D.MipLevels = (mMipLevels == 0 ? -1 : mMipLevels);
+        srvDesc.Texture3D.MostDetailedMip = 0;
+
+        HRESULT result = device->CreateShaderResourceView(mTexture, &srvDesc, &mSRV);
+
+        if (result == E_OUTOFMEMORY)
+        {
+            return gl::error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
+        }
+        ASSERT(SUCCEEDED(result));
+    }
+
+    return mSRV;
+}
+
+void TextureStorage11_3D::generateMipmap(int level)
+{
+    UNIMPLEMENTED();
+}
+
 }

src/libGLESv2/renderer/TextureStorage11.h

@@ -34,7 +34,7 @@ class TextureStorage11 : public TextureStorage
 
     UINT getBindFlags() const;
 
-    virtual ID3D11Texture2D *getBaseTexture() const;
+    virtual ID3D11Resource *getBaseTexture() const = 0;
     virtual ID3D11ShaderResourceView *getSRV() = 0;
     virtual RenderTarget *getRenderTarget() { return getRenderTarget(0); }
     virtual RenderTarget *getRenderTarget(int level) { return NULL; }
@@ -50,8 +50,9 @@ class TextureStorage11 : public TextureStorage
     virtual int levelCount();
     UINT getSubresourceIndex(int level, int faceTarget);
 
-    bool updateSubresourceLevel(ID3D11Texture2D *texture, unsigned int sourceSubresource, int level,
-                                int faceTarget, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+    bool updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource, int level,
+                                int faceTarget, GLint xoffset, GLint yoffset, GLint zoffset,
+                                GLsizei width, GLsizei height, GLsizei depth);
 
   protected:
     void generateMipmapLayer(RenderTarget11 *source, RenderTarget11 *dest);
@@ -60,13 +61,13 @@ class TextureStorage11 : public TextureStorage
     int mLodOffset;
     unsigned int mMipLevels;
 
-    ID3D11Texture2D *mTexture;
     DXGI_FORMAT mTextureFormat;
     DXGI_FORMAT mShaderResourceFormat;
     DXGI_FORMAT mRenderTargetFormat;
     DXGI_FORMAT mDepthStencilFormat;
     unsigned int mTextureWidth;
     unsigned int mTextureHeight;
+    unsigned int mTextureDepth;
 
     ID3D11ShaderResourceView *mSRV;
 
@@ -85,6 +86,7 @@ class TextureStorage11_2D : public TextureStorage11
 
     static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
 
+    virtual ID3D11Resource *getBaseTexture() const;
     virtual ID3D11ShaderResourceView *getSRV();
     virtual RenderTarget *getRenderTarget(int level);
 
@@ -93,6 +95,7 @@ class TextureStorage11_2D : public TextureStorage11
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
 
+    ID3D11Texture2D *mTexture;
     RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
@@ -104,6 +107,7 @@ class TextureStorage11_Cube : public TextureStorage11
 
     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
 
+    virtual ID3D11Resource *getBaseTexture() const;
     virtual ID3D11ShaderResourceView *getSRV();
     virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level);
 
@@ -112,9 +116,30 @@ class TextureStorage11_Cube : public TextureStorage11
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
 
+    ID3D11Texture2D *mTexture;
     RenderTarget11 *mRenderTarget[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
+class TextureStorage11_3D : public TextureStorage11
+{
+  public:
+    TextureStorage11_3D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage,
+                        GLsizei width, GLsizei height, GLsizei depth);
+    virtual ~TextureStorage11_3D();
+
+    static TextureStorage11_3D *makeTextureStorage11_3D(TextureStorage *storage);
+
+    virtual ID3D11Resource *getBaseTexture() const;
+    virtual ID3D11ShaderResourceView *getSRV();
+
+    virtual void generateMipmap(int level);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureStorage11_3D);
+
+    ID3D11Texture3D *mTexture;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTURESTORAGE11_H_