Texture storage now has deferred creation of all render targets and shader resources.

src/libGLESv2/renderer/TextureStorage.h

@@ -35,8 +35,8 @@ class TextureStorage
     virtual bool isManaged() const = 0;
     virtual int levelCount() = 0;
 
-    virtual RenderTarget *getRenderTarget() const = 0;
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget) const = 0;
+    virtual RenderTarget *getRenderTarget() = 0;
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget) = 0;
     virtual void generateMipmap(int level) = 0;
     virtual void generateMipmap(int face, int level) = 0;
 

src/libGLESv2/renderer/TextureStorage11.cpp

@@ -131,7 +131,7 @@ bool TextureStorage11::updateSubresourceLevel(ID3D11Texture2D *srcTexture, int l
 
         ID3D11DeviceContext *context = mRenderer->getDeviceContext();
         
-        ASSERT(getBaseTexture());        
+        ASSERT(getBaseTexture());
         context->CopySubresourceRegion(getBaseTexture(), getSubresourceIndex(level, face), xoffset, yoffset, 0, srcTexture, 0, &srcBox);
         return true;
     }
@@ -145,15 +145,19 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, SwapChain11 *swapch
     ID3D11Texture2D *surfaceTexture = swapchain->getOffscreenTexture();
     mTexture = surfaceTexture;
     mSRV = NULL;
-    mRenderTarget = NULL;
+
+    for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
+    {
+        mRenderTarget[i] = NULL;
+    }
 
     D3D11_TEXTURE2D_DESC desc;
     surfaceTexture->GetDesc(&desc);
 
     mMipLevels = desc.MipLevels;
-
-    initializeSRV(desc.Format);
-    initializeRenderTarget(desc.Format, desc.Width, desc.Height);
+    mTextureFormat = desc.Format;
+    mTextureWidth = desc.Width;
+    mTextureHeight = desc.Height;
 }
 
 TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, GLsizei width, GLsizei height)
@@ -161,9 +165,15 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum
 {
     mTexture = NULL;
     mSRV = NULL;
-    mRenderTarget = NULL;
+    mTextureWidth = 0;
+    mTextureHeight = 0;
     DXGI_FORMAT format = gl_d3d11::ConvertTextureFormat(internalformat);
 
+    for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
+    {
+        mRenderTarget[i] = NULL;
+    }
+
     // if the width or height is 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)
@@ -198,11 +208,11 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer *renderer, int levels, GLenum
         {
             mTexture->GetDesc(&desc);
             mMipLevels = desc.MipLevels;
+            mTextureFormat = desc.Format;
+            mTextureWidth = desc.Width;
+            mTextureHeight = desc.Height;
         }
     }
-
-    initializeSRV(format);
-    initializeRenderTarget(format, width, height);
 }
 
 TextureStorage11_2D::~TextureStorage11_2D()
@@ -219,16 +229,10 @@ TextureStorage11_2D::~TextureStorage11_2D()
         mSRV = NULL;
     }
 
-    if (mRenderTarget)
+    for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; i++)
     {
-        for (unsigned int i = 0; i < mMipLevels; i++)
-        {
-            delete mRenderTarget[i];
-            mRenderTarget[i] = NULL;
-        }
-
-        delete[] mRenderTarget;
-        mRenderTarget = NULL;
+        delete mRenderTarget[i];
+        mRenderTarget[i] = NULL;
     }
 }
 
@@ -238,15 +242,39 @@ TextureStorage11_2D *TextureStorage11_2D::makeTextureStorage11_2D(TextureStorage
     return static_cast<TextureStorage11_2D*>(storage);
 }
 
-RenderTarget *TextureStorage11_2D::getRenderTarget(int level) const
+RenderTarget *TextureStorage11_2D::getRenderTarget(int level)
 {
-    if (level < 0 || level >= static_cast<int>(mMipLevels))
+    if (level >= 0 && level < static_cast<int>(mMipLevels))
     {
-        return NULL;
+        if (!mRenderTarget[level])
+        {
+            ID3D11Device *device = mRenderer->getDevice();
+            HRESULT result;
+
+            D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
+            rtvDesc.Format = mTextureFormat;
+            rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
+            rtvDesc.Texture2D.MipSlice = level;
+
+            ID3D11RenderTargetView *rtv;
+            result = device->CreateRenderTargetView(mTexture, &rtvDesc, &rtv);
+
+            if (result == E_OUTOFMEMORY)
+            {
+                return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
+            }
+            ASSERT(SUCCEEDED(result));
+
+            mRenderTarget[level] = new RenderTarget11(mRenderer, rtv,
+                                                      std::max(mTextureWidth >> level, 1U),
+                                                      std::max(mTextureHeight >> level, 1U));
+        }
+
+        return mRenderTarget[level];
     }
     else
     {
-        return mRenderTarget[level];
+        return NULL;
     }
 }
 
@@ -255,79 +283,34 @@ ID3D11Texture2D *TextureStorage11_2D::getBaseTexture() const
     return mTexture;
 }
 
-ID3D11ShaderResourceView *TextureStorage11_2D::getSRV() const
-{
-    return mSRV;
-}
-
-void TextureStorage11_2D::generateMipmap(int level)
-{
-    // TODO
-    UNIMPLEMENTED();
-}
-
-void TextureStorage11_2D::initializeRenderTarget(DXGI_FORMAT format, int width, int height)
+ID3D11ShaderResourceView *TextureStorage11_2D::getSRV()
 {
-    ASSERT(mRenderTarget == NULL);
-
-    if (mTexture != NULL && isRenderTarget())
+    if (!mSRV)
     {
-        if (getBindFlags() & D3D11_BIND_RENDER_TARGET)
-        {
-            mRenderTarget = new RenderTarget11*[mMipLevels];
-            for (unsigned i = 0; i < mMipLevels; i++)
-            {
-                // Create render target view -- texture should already be created with
-                // BIND_RENDER_TARGET flag.
-                D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
-                rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
-                rtvDesc.Format = format;
-                rtvDesc.Texture2D.MipSlice = i;
-
-                ID3D11RenderTargetView *renderTargetView;
-                ID3D11Device *device = mRenderer->getDevice();
-                HRESULT result = device->CreateRenderTargetView(mTexture, &rtvDesc, &renderTargetView);
-
-                if (result == E_OUTOFMEMORY)
-                    return;
-
-                ASSERT(SUCCEEDED(result));
-
-                mRenderTarget[i] = new RenderTarget11(mRenderer, renderTargetView, std::max(width >> i, 1), std::max(height >> i, 1));
-            }
-        }
-        else if (getBindFlags() & D3D11_BIND_DEPTH_STENCIL)
-        {
-            // TODO
-            UNIMPLEMENTED();
-        }
-        else
-            UNREACHABLE();
-    }
-}
-
-void TextureStorage11_2D::initializeSRV(DXGI_FORMAT format)
-{
-    ASSERT(mSRV == NULL);
+        ID3D11Device *device = mRenderer->getDevice();
 
-    if (mTexture)
-    {
         D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
-        srvDesc.Format = format;
+        srvDesc.Format = mTextureFormat;
         srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
-        srvDesc.Texture2D.MostDetailedMip = 0;
         srvDesc.Texture2D.MipLevels = (mMipLevels == 0 ? -1 : mMipLevels);
+        srvDesc.Texture2D.MostDetailedMip = 0;
 
-        ID3D11Device *device = mRenderer->getDevice();
         HRESULT result = device->CreateShaderResourceView(mTexture, &srvDesc, &mSRV);
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY);
+            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
-
         ASSERT(SUCCEEDED(result));
     }
+
+    return mSRV;
+}
+
+void TextureStorage11_2D::generateMipmap(int level)
+{
+    // TODO
+    UNIMPLEMENTED();
 }
 
 TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLenum internalformat, GLenum usage, bool forceRenderable, int size)
@@ -335,10 +318,15 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLe
 {
     mTexture = NULL;
     mSRV = NULL;
+    mTextureWidth = 0;
+    mTextureHeight = 0;
 
-    for (unsigned int i = 0; i < 6; ++i)
+    for (unsigned int i = 0; i < 6; i++)
     {
-        mRenderTarget[i] = NULL;
+        for (unsigned int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; j++)
+        {
+            mRenderTarget[i][j] = NULL;
+        }
     }
 
     DXGI_FORMAT format = gl_d3d11::ConvertTextureFormat(internalformat);
@@ -377,11 +365,11 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer *renderer, int levels, GLe
         {
             mTexture->GetDesc(&desc);
             mMipLevels = desc.MipLevels;
+            mTextureFormat = desc.Format;
+            mTextureWidth = desc.Width;
+            mTextureHeight = desc.Height;
         }
     }
-
-    initializeSRV(format);
-    initializeRenderTarget(format, size);
 }
 
 TextureStorage11_Cube::~TextureStorage11_Cube()
@@ -400,16 +388,10 @@ TextureStorage11_Cube::~TextureStorage11_Cube()
 
     for (unsigned int i = 0; i < 6; i++)
     {
-        if (mRenderTarget[i])
+        for (unsigned int j = 0; j < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; j++)
         {
-            for (unsigned int j = 0; j < mMipLevels; j++)
-            {
-                delete mRenderTarget[i][j];
-                mRenderTarget[i][j] = NULL;
-            }
-
-            delete[] mRenderTarget[i];
-            mRenderTarget[i] = NULL;
+            delete mRenderTarget[i][j];
+            mRenderTarget[i][j] = NULL;
         }
     }
 }
@@ -420,103 +402,87 @@ TextureStorage11_Cube *TextureStorage11_Cube::makeTextureStorage11_Cube(TextureS
     return static_cast<TextureStorage11_Cube*>(storage);
 }
 
-RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int level) const
+RenderTarget *TextureStorage11_Cube::getRenderTarget(GLenum faceTarget, int level)
 {
-    if (level < 0 || level >= static_cast<int>(mMipLevels))
+    unsigned int faceIdx = gl::TextureCubeMap::faceIndex(faceTarget);
+    if (level >= 0 && level < static_cast<int>(mMipLevels))
     {
-        return NULL;
-    }
-    else
-    {
-        return mRenderTarget[gl::TextureCubeMap::faceIndex(faceTarget)][level];
-    }
-}
-
-ID3D11Texture2D *TextureStorage11_Cube::getBaseTexture() const
-{
-    return mTexture;
-}
-
-ID3D11ShaderResourceView *TextureStorage11_Cube::getSRV() const
-{
-    return mSRV;
-}
-
-void TextureStorage11_Cube::generateMipmap(int face, int level)
-{
-    // TODO
-    UNIMPLEMENTED();
-}
-
-void TextureStorage11_Cube::initializeRenderTarget(DXGI_FORMAT format, int size)
-{
-    if (mTexture != NULL && isRenderTarget())
-    {
-        if (getBindFlags() & D3D11_BIND_RENDER_TARGET)
+        if (!mRenderTarget[faceIdx][level])
         {
-            // Create render target view -- texture should already be created with 
-            // BIND_RENDER_TARGET flag.
+            ID3D11Device *device = mRenderer->getDevice();
+            HRESULT result;
 
-            for (unsigned int i = 0; i < 6; ++i)
+            if (getBindFlags() & D3D11_BIND_RENDER_TARGET)
             {
-                ASSERT(mRenderTarget[i] == NULL);
-                mRenderTarget[i] = new RenderTarget11*[mMipLevels];
-
-                for (unsigned int j = 0; j < mMipLevels; j++)
-                {
-                    D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
-                    rtvDesc.Format = format;
-                    rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
-                    rtvDesc.Texture2DArray.MipSlice = j;
-                    rtvDesc.Texture2DArray.FirstArraySlice = i;
-                    rtvDesc.Texture2DArray.ArraySize = 1;
-
-                    ID3D11RenderTargetView *renderTargetView;
-                    ID3D11Device *device = mRenderer->getDevice();
-                    HRESULT result = device->CreateRenderTargetView(mTexture, &rtvDesc, &renderTargetView);
-
-                    if (result == E_OUTOFMEMORY)
-                        return;
+                D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
+                rtvDesc.Format = mTextureFormat;
+                rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
+                rtvDesc.Texture2DArray.MipSlice = level;
+                rtvDesc.Texture2DArray.FirstArraySlice = faceIdx;
+                rtvDesc.Texture2DArray.ArraySize = 1;
 
-                    ASSERT(SUCCEEDED(result));
+                ID3D11RenderTargetView *rtv;
+                result = device->CreateRenderTargetView(mTexture, &rtvDesc, &rtv);
 
-                    int mipSize = size >> j;
-                    mRenderTarget[i][j] = new RenderTarget11(mRenderer, renderTargetView, mipSize, mipSize);
+                if (result == E_OUTOFMEMORY)
+                {
+                    return error(GL_OUT_OF_MEMORY, static_cast<RenderTarget*>(NULL));
                 }
+                ASSERT(SUCCEEDED(result));
+
+                mRenderTarget[faceIdx][level] = new RenderTarget11(mRenderer, rtv,
+                                                                   std::max(mTextureWidth >> level, 1U),
+                                                                   std::max(mTextureHeight >> level, 1U));
             }
+            else if (getBindFlags() & D3D11_BIND_DEPTH_STENCIL)
+            {
+                // TODO
+                UNIMPLEMENTED();
+            }
+            else UNREACHABLE();
         }
-        else if (getBindFlags() & D3D11_BIND_DEPTH_STENCIL)
-        {
-            // TODO
-            UNIMPLEMENTED();
-        }
-        else
-            UNREACHABLE();
+
+        return mRenderTarget[faceIdx][level];
+    }
+    else
+    {
+        return NULL;
     }
 }
 
-void TextureStorage11_Cube::initializeSRV(DXGI_FORMAT format)
+ID3D11Texture2D *TextureStorage11_Cube::getBaseTexture() const
 {
-    ASSERT(mSRV == NULL);
+    return mTexture;
+}
 
-    if (mTexture)
+ID3D11ShaderResourceView *TextureStorage11_Cube::getSRV()
+{
+    if (!mSRV)
     {
+        ID3D11Device *device = mRenderer->getDevice();
+
         D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
-        srvDesc.Format = format;
+        srvDesc.Format = mTextureFormat;
         srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
         srvDesc.TextureCube.MipLevels = (mMipLevels == 0 ? -1 : mMipLevels);
         srvDesc.TextureCube.MostDetailedMip = 0;
 
-        ID3D11Device *device = mRenderer->getDevice();
         HRESULT result = device->CreateShaderResourceView(mTexture, &srvDesc, &mSRV);
 
         if (result == E_OUTOFMEMORY)
         {
-            return error(GL_OUT_OF_MEMORY);
+            return error(GL_OUT_OF_MEMORY, static_cast<ID3D11ShaderResourceView*>(NULL));
         }
-
         ASSERT(SUCCEEDED(result));
     }
+
+    return mSRV;
+}
+
+void TextureStorage11_Cube::generateMipmap(int face, int level)
+{
+    // TODO
+    UNIMPLEMENTED();
 }
 
-}
\ No newline at end of file
+}

src/libGLESv2/renderer/TextureStorage11.h

@@ -12,6 +12,7 @@
 
 #include <d3d11.h>
 
+#include "libGLESv2/Texture.h"
 #include "libGLESv2/renderer/TextureStorage.h"
 
 namespace rx
@@ -36,11 +37,12 @@ class TextureStorage11 : public TextureStorage
     UINT getBindFlags() const;
 
     virtual ID3D11Texture2D *getBaseTexture() const = 0;
-    virtual ID3D11ShaderResourceView *getSRV() const = 0;
-    virtual RenderTarget *getRenderTarget() const { return getRenderTarget(0); }
-    virtual RenderTarget *getRenderTarget(int level) const { return NULL; }
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget) const { return getRenderTarget(faceTarget, 0); }
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level) const { return NULL; }
+    virtual ID3D11ShaderResourceView *getSRV() = 0;
+    virtual RenderTarget *getRenderTarget() { return getRenderTarget(0); }
+    virtual RenderTarget *getRenderTarget(int level) { return NULL; }
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget) { return getRenderTarget(faceTarget, 0); }
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level) { return NULL; }
+
     virtual void generateMipmap(int level) {};
     virtual void generateMipmap(int face, int level) {};
 
@@ -49,7 +51,7 @@ class TextureStorage11 : public TextureStorage
     virtual bool isManaged() const;
     virtual int levelCount();
     UINT getSubresourceIndex(int level, int faceTarget);
-    
+
     bool updateSubresourceLevel(ID3D11Texture2D *texture, int level, int faceTarget, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
 
   protected:
@@ -72,20 +74,22 @@ class TextureStorage11_2D : public TextureStorage11
 
     static TextureStorage11_2D *makeTextureStorage11_2D(TextureStorage *storage);
 
-    virtual RenderTarget *getRenderTarget(int level) const;
     virtual ID3D11Texture2D *getBaseTexture() const;
-    virtual ID3D11ShaderResourceView *getSRV() const;
+    virtual ID3D11ShaderResourceView *getSRV();
+    virtual RenderTarget *getRenderTarget(int level);
+
     virtual void generateMipmap(int level);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_2D);
 
-    void initializeRenderTarget(DXGI_FORMAT format, int width, int height);
-    void initializeSRV(DXGI_FORMAT format);
-
     ID3D11Texture2D *mTexture;
+    DXGI_FORMAT mTextureFormat;
+    unsigned int mTextureWidth;
+    unsigned int mTextureHeight;
+
     ID3D11ShaderResourceView *mSRV;
-    RenderTarget11 **mRenderTarget;
+    RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
 class TextureStorage11_Cube : public TextureStorage11
@@ -96,20 +100,22 @@ class TextureStorage11_Cube : public TextureStorage11
 
     static TextureStorage11_Cube *makeTextureStorage11_Cube(TextureStorage *storage);
 
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level) const;
     virtual ID3D11Texture2D *getBaseTexture() const;
-    virtual ID3D11ShaderResourceView *getSRV() const;
+    virtual ID3D11ShaderResourceView *getSRV();
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget, int level);
+
     virtual void generateMipmap(int face, int level);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage11_Cube);
 
-    void initializeRenderTarget(DXGI_FORMAT format, int size);
-    void initializeSRV(DXGI_FORMAT format);
-
     ID3D11Texture2D *mTexture;
+    DXGI_FORMAT mTextureFormat;
+    unsigned int mTextureWidth;
+    unsigned int mTextureHeight;
+
     ID3D11ShaderResourceView *mSRV;
-    RenderTarget11 **mRenderTarget[6];
+    RenderTarget11 *mRenderTarget[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
 }

src/libGLESv2/renderer/TextureStorage9.cpp

@@ -178,7 +178,7 @@ IDirect3DSurface9 *TextureStorage9_2D::getSurfaceLevel(int level, bool dirty)
     return surface;
 }
 
-RenderTarget *TextureStorage9_2D::getRenderTarget() const
+RenderTarget *TextureStorage9_2D::getRenderTarget()
 {
     return mRenderTarget;
 }
@@ -284,7 +284,7 @@ IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, in
     return surface;
 }
 
-RenderTarget *TextureStorage9_Cube::getRenderTarget(GLenum faceTarget) const
+RenderTarget *TextureStorage9_Cube::getRenderTarget(GLenum faceTarget)
 {
     return mRenderTarget[gl::TextureCubeMap::faceIndex(faceTarget)];
 }

src/libGLESv2/renderer/TextureStorage9.h

@@ -41,8 +41,8 @@ class TextureStorage9 : public TextureStorage
     DWORD getUsage() const;
 
     virtual IDirect3DBaseTexture9 *getBaseTexture() const = 0;
-    virtual RenderTarget *getRenderTarget() const { return NULL; }
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget) const { return NULL; }
+    virtual RenderTarget *getRenderTarget() { return NULL; }
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget) { return NULL; }
     virtual void generateMipmap(int level) {};
     virtual void generateMipmap(int face, int level) {};
 
@@ -72,7 +72,7 @@ class TextureStorage9_2D : public TextureStorage9
     static TextureStorage9_2D *makeTextureStorage9_2D(TextureStorage *storage);
 
     IDirect3DSurface9 *getSurfaceLevel(int level, bool dirty);
-    virtual RenderTarget *getRenderTarget() const;
+    virtual RenderTarget *getRenderTarget();
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
     virtual void generateMipmap(int level);
 
@@ -94,7 +94,7 @@ class TextureStorage9_Cube : public TextureStorage9
     static TextureStorage9_Cube *makeTextureStorage9_Cube(TextureStorage *storage);
 
     IDirect3DSurface9 *getCubeMapSurface(GLenum faceTarget, int level, bool dirty);
-    virtual RenderTarget *getRenderTarget(GLenum faceTarget) const;
+    virtual RenderTarget *getRenderTarget(GLenum faceTarget);
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
     virtual void generateMipmap(int face, int level);