Move generateMipmap to storage interface base class.

src/libGLESv2/renderer/d3d/TextureD3D.cpp

@@ -501,10 +501,9 @@ void TextureD3D_2D::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
+        mTexStorage->getStorageInstance()->generateMipmaps();
         for (int level = 1; level < levelCount; level++)
         {
-            mTexStorage->generateMipmap(level);
-
             mImageArray[level]->markClean();
         }
     }
@@ -1000,12 +999,12 @@ void TextureD3D_Cube::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
+        mTexStorage->getStorageInstance()->generateMipmaps();
+
         for (int faceIndex = 0; faceIndex < 6; faceIndex++)
         {
             for (int level = 1; level < levelCount; level++)
             {
-                mTexStorage->generateMipmap(faceIndex, level);
-
                 mImageArray[faceIndex][level]->markClean();
             }
         }
@@ -1498,10 +1497,10 @@ void TextureD3D_3D::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
+        mTexStorage->getStorageInstance()->generateMipmaps();
+
         for (int level = 1; level < levelCount; level++)
         {
-            mTexStorage->generateMipmap(level);
-
             mImageArray[level]->markClean();
         }
     }
@@ -1982,10 +1981,10 @@ void TextureD3D_2DArray::generateMipmaps()
 
     if (mTexStorage && mTexStorage->isRenderTarget())
     {
+        mTexStorage->getStorageInstance()->generateMipmaps();
+
         for (int level = 1; level < levelCount; level++)
         {
-            mTexStorage->generateMipmap(level);
-
             for (int layer = 0; layer < mLayerCounts[level]; layer++)
             {
                 mImageArray[level][layer]->markClean();

src/libGLESv2/renderer/d3d/TextureStorage.cpp

@@ -80,11 +80,6 @@ TextureStorageInterface2D::TextureStorageInterface2D(TextureStorage *storageInst
 TextureStorageInterface2D::~TextureStorageInterface2D()
 {}
 
-void TextureStorageInterface2D::generateMipmap(int level)
-{
-    mInstance->generateMipmap(level);
-}
-
 TextureStorageInterfaceCube::TextureStorageInterfaceCube(TextureStorage *storageInstance)
     : TextureStorageInterface(storageInstance, 6)
 {}
@@ -92,11 +87,6 @@ TextureStorageInterfaceCube::TextureStorageInterfaceCube(TextureStorage *storage
 TextureStorageInterfaceCube::~TextureStorageInterfaceCube()
 {}
 
-void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
-{
-    mInstance->generateMipmap(faceIndex, level);
-}
-
 TextureStorageInterface3D::TextureStorageInterface3D(TextureStorage *storageInstance, unsigned int depth)
     : TextureStorageInterface(storageInstance, depth)
 {}
@@ -104,11 +94,6 @@ TextureStorageInterface3D::TextureStorageInterface3D(TextureStorage *storageInst
 TextureStorageInterface3D::~TextureStorageInterface3D()
 {}
 
-void TextureStorageInterface3D::generateMipmap(int level)
-{
-    mInstance->generateMipmap(level);
-}
-
 TextureStorageInterface2DArray::TextureStorageInterface2DArray(TextureStorage *storageInstance, unsigned int depth)
     : TextureStorageInterface(storageInstance, depth)
 {}
@@ -116,9 +101,4 @@ TextureStorageInterface2DArray::TextureStorageInterface2DArray(TextureStorage *s
 TextureStorageInterface2DArray::~TextureStorageInterface2DArray()
 {}
 
-void TextureStorageInterface2DArray::generateMipmap(int level)
-{
-    mInstance->generateMipmap(level);
-}
-
 }

src/libGLESv2/renderer/d3d/TextureStorage.h

@@ -38,8 +38,7 @@ class TextureStorage
     virtual int getLevelCount() const = 0;
 
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
-    virtual void generateMipmap(int level) = 0;
-    virtual void generateMipmap(int face, int level) = 0;
+    virtual void generateMipmaps() = 0;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage);
@@ -85,8 +84,6 @@ class TextureStorageInterface2D : public TextureStorageInterface
     TextureStorageInterface2D(TextureStorage *storageInstance);
     virtual ~TextureStorageInterface2D();
 
-    void generateMipmap(int level);
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorageInterface2D);
 };
@@ -97,8 +94,6 @@ class TextureStorageInterfaceCube : public TextureStorageInterface
     TextureStorageInterfaceCube(TextureStorage *storageInstance);
     virtual ~TextureStorageInterfaceCube();
 
-    void generateMipmap(int faceIndex, int level);
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorageInterfaceCube);
 };
@@ -109,8 +104,6 @@ class TextureStorageInterface3D : public TextureStorageInterface
     TextureStorageInterface3D(TextureStorage *storageInstance, unsigned int depth);
     virtual ~TextureStorageInterface3D();
 
-    void generateMipmap(int level);
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorageInterface3D);
 };
@@ -121,8 +114,6 @@ class TextureStorageInterface2DArray : public TextureStorageInterface
     TextureStorageInterface2DArray(TextureStorage *storageInstance, unsigned int depth);
     virtual ~TextureStorageInterface2DArray();
 
-    void generateMipmap(int level);
-
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorageInterface2DArray);
 };

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.cpp

@@ -706,17 +706,22 @@ ID3D11ShaderResourceView *TextureStorage11_2D::createSRV(int baseLevel, int mipL
     return SRV;
 }
 
-void TextureStorage11_2D::generateMipmap(int level)
+void TextureStorage11_2D::generateMipmaps()
 {
-    invalidateSwizzleCacheLevel(level);
+    // Base level must already be defined
 
-    gl::ImageIndex srcIndex = gl::ImageIndex::Make2D(level - 1);
-    gl::ImageIndex destIndex = gl::ImageIndex::Make2D(level);
+    for (int level = 1; level < getLevelCount(); level++)
+    {
+        invalidateSwizzleCacheLevel(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));
+        RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+        RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
-    generateMipmapLayer(source, dest);
+        generateMipmapLayer(source, dest);
+    }
 }
 
 ID3D11Resource *TextureStorage11_2D::getSwizzleTexture()
@@ -1109,17 +1114,25 @@ ID3D11ShaderResourceView *TextureStorage11_Cube::createSRV(int baseLevel, int mi
     return SRV;
 }
 
-void TextureStorage11_Cube::generateMipmap(int faceIndex, int level)
+void TextureStorage11_Cube::generateMipmaps()
 {
-    invalidateSwizzleCacheLevel(level);
+    // Base level must already be defined
 
-    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);
+    for (int faceIndex = 0; faceIndex < 6; faceIndex++)
+    {
+        for (int level = 1; level < getLevelCount(); level++)
+        {
+            invalidateSwizzleCacheLevel(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));
+            RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+            RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
-    generateMipmapLayer(source, dest);
+            generateMipmapLayer(source, dest);
+        }
+    }
 }
 
 ID3D11Resource *TextureStorage11_Cube::getSwizzleTexture()
@@ -1482,17 +1495,22 @@ RenderTarget *TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index)
     return NULL;
 }
 
-void TextureStorage11_3D::generateMipmap(int level)
+void TextureStorage11_3D::generateMipmaps()
 {
-    invalidateSwizzleCacheLevel(level);
+    // Base level must already be defined
+
+    for (int level = 1; level < getLevelCount(); level++)
+    {
+        invalidateSwizzleCacheLevel(level);
 
-    gl::ImageIndex srcIndex = gl::ImageIndex::Make3D(level - 1);
-    gl::ImageIndex destIndex = gl::ImageIndex::Make3D(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));
+        RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(srcIndex));
+        RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
-    generateMipmapLayer(source, dest);
+        generateMipmapLayer(source, dest);
+    }
 }
 
 ID3D11Resource *TextureStorage11_3D::getSwizzleTexture()
@@ -1832,18 +1850,23 @@ RenderTarget *TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &in
     }
 }
 
-void TextureStorage11_2DArray::generateMipmap(int level)
+void TextureStorage11_2DArray::generateMipmaps()
 {
-    invalidateSwizzleCacheLevel(level);
-    for (unsigned int layer = 0; layer < mTextureDepth; layer++)
+    // Base level must already be defined
+
+    for (int level = 0; level < getLevelCount(); level++)
     {
-        gl::ImageIndex sourceIndex = gl::ImageIndex::Make2DArray(level - 1, layer);
-        gl::ImageIndex destIndex = gl::ImageIndex::Make2DArray(level, layer);
+        invalidateSwizzleCacheLevel(level);
+        for (unsigned int layer = 0; layer < mTextureDepth; 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));
+            RenderTarget11 *source = RenderTarget11::makeRenderTarget11(getRenderTarget(sourceIndex));
+            RenderTarget11 *dest = RenderTarget11::makeRenderTarget11(getRenderTarget(destIndex));
 
-        generateMipmapLayer(source, dest);
+            generateMipmapLayer(source, dest);
+        }
     }
 }
 

src/libGLESv2/renderer/d3d/d3d11/TextureStorage11.h

@@ -44,8 +44,7 @@ class TextureStorage11 : public TextureStorage
     virtual ID3D11ShaderResourceView *getSRV(const gl::SamplerState &samplerState);
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
 
-    virtual void generateMipmap(int level) {};
-    virtual void generateMipmap(int face, int level) {};
+    virtual void generateMipmaps() = 0;
 
     virtual int getTopLevel() const;
     virtual bool isRenderTarget() const;
@@ -165,7 +164,7 @@ class TextureStorage11_2D : public TextureStorage11
     virtual ID3D11Resource *getResource() const;
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
-    virtual void generateMipmap(int level);
+    virtual void generateMipmaps();
 
     virtual void associateImage(Image11* image, int level, int layerTarget);
     virtual void disassociateImage(int level, int layerTarget, Image11* expectedImage);
@@ -203,7 +202,7 @@ class TextureStorage11_Cube : public TextureStorage11
     virtual ID3D11Resource *getResource() const;
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
-    virtual void generateMipmap(int faceIndex, int level);
+    virtual void generateMipmaps();
 
     virtual void associateImage(Image11* image, int level, int layerTarget);
     virtual void disassociateImage(int level, int layerTarget, Image11* expectedImage);
@@ -244,7 +243,7 @@ class TextureStorage11_3D : public TextureStorage11
     // Handles both layer and non-layer RTs
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
-    virtual void generateMipmap(int level);
+    virtual void generateMipmaps();
 
     virtual void associateImage(Image11* image, int level, int layerTarget);
     virtual void disassociateImage(int level, int layerTarget, Image11* expectedImage);
@@ -287,7 +286,7 @@ class TextureStorage11_2DArray : public TextureStorage11
     virtual ID3D11Resource *getResource() const;
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
 
-    virtual void generateMipmap(int level);
+    virtual void generateMipmaps();
 
     virtual void associateImage(Image11* image, int level, int layerTarget);
     virtual void disassociateImage(int level, int layerTarget, Image11* expectedImage);

src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.cpp

@@ -162,18 +162,23 @@ RenderTarget *TextureStorage9_2D::getRenderTarget(const gl::ImageIndex &/*index*
     return mRenderTarget;
 }
 
-void TextureStorage9_2D::generateMipmap(int level)
+void TextureStorage9_2D::generateMipmaps()
 {
-    IDirect3DSurface9 *upper = getSurfaceLevel(level - 1, false);
-    IDirect3DSurface9 *lower = getSurfaceLevel(level, true);
+    // Base level must already be defined
 
-    if (upper != NULL && lower != NULL)
+    for (int level = 1; level < getLevelCount(); level++)
     {
-        mRenderer->boxFilter(upper, lower);
-    }
+        IDirect3DSurface9 *upper = getSurfaceLevel(level - 1, false);
+        IDirect3DSurface9 *lower = getSurfaceLevel(level, true);
 
-    SafeRelease(upper);
-    SafeRelease(lower);
+        if (upper != NULL && lower != NULL)
+        {
+            mRenderer->boxFilter(upper, lower);
+        }
+
+        SafeRelease(upper);
+        SafeRelease(lower);
+    }
 }
 
 IDirect3DBaseTexture9 *TextureStorage9_2D::getBaseTexture() const
@@ -268,18 +273,26 @@ RenderTarget *TextureStorage9_Cube::getRenderTarget(const gl::ImageIndex &index)
     return mRenderTarget[index.layerIndex];
 }
 
-void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)
+void TextureStorage9_Cube::generateMipmaps()
 {
-    IDirect3DSurface9 *upper = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level - 1, false);
-    IDirect3DSurface9 *lower = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, true);
+    // Base level must already be defined
 
-    if (upper != NULL && lower != NULL)
+    for (int faceIndex = 0; faceIndex < 6; faceIndex++)
     {
-        mRenderer->boxFilter(upper, lower);
-    }
+        for (int level = 1; level < getLevelCount(); level++)
+        {
+            IDirect3DSurface9 *upper = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level - 1, false);
+            IDirect3DSurface9 *lower = getCubeMapSurface(GL_TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, level, true);
+
+            if (upper != NULL && lower != NULL)
+            {
+                mRenderer->boxFilter(upper, lower);
+            }
 
-    SafeRelease(upper);
-    SafeRelease(lower);
+            SafeRelease(upper);
+            SafeRelease(lower);
+        }
+    }
 }
 
 IDirect3DBaseTexture9 *TextureStorage9_Cube::getBaseTexture() const

src/libGLESv2/renderer/d3d/d3d9/TextureStorage9.h

@@ -35,8 +35,7 @@ class TextureStorage9 : public TextureStorage
 
     virtual IDirect3DBaseTexture9 *getBaseTexture() const = 0;
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index) = 0;
-    virtual void generateMipmap(int level) {};
-    virtual void generateMipmap(int face, int level) {};
+    virtual void generateMipmaps() = 0;
 
     virtual int getTopLevel() const;
     virtual bool isRenderTarget() const;
@@ -68,7 +67,7 @@ class TextureStorage9_2D : public TextureStorage9
     IDirect3DSurface9 *getSurfaceLevel(int level, bool dirty);
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
-    virtual void generateMipmap(int level);
+    virtual void generateMipmaps();
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage9_2D);
@@ -90,7 +89,7 @@ class TextureStorage9_Cube : public TextureStorage9
     IDirect3DSurface9 *getCubeMapSurface(GLenum faceTarget, int level, bool dirty);
     virtual RenderTarget *getRenderTarget(const gl::ImageIndex &index);
     virtual IDirect3DBaseTexture9 *getBaseTexture() const;
-    virtual void generateMipmap(int faceIndex, int level);
+    virtual void generateMipmaps();
 
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureStorage9_Cube);