Refactored Texture2DArray, separated out D3D logic

src/libGLESv2/Context.cpp

@@ -69,7 +69,7 @@ Context::Context(int clientVersion, const gl::Context *shareContext, rx::Rendere
     mTexture2DZero.set(new Texture2D(mRenderer->createTexture2D(), 0));
     mTextureCubeMapZero.set(new TextureCubeMap(mRenderer->createTextureCube(), 0));
     mTexture3DZero.set(new Texture3D(mRenderer->createTexture3D(), 0));
-    mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
+    mTexture2DArrayZero.set(new Texture2DArray(mRenderer->createTexture2DArray(), 0));
 
     bindVertexArray(0);
     bindArrayBuffer(0);
@@ -2176,7 +2176,7 @@ Texture *Context::getIncompleteTexture(TextureType type)
 
           case TEXTURE_2D_ARRAY:
             {
-                Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
+                Texture2DArray *incomplete2darray = new Texture2DArray(mRenderer->createTexture2DArray(), Texture::INCOMPLETE_TEXTURE_ID);
                 incomplete2darray->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
 
                 t = incomplete2darray;

src/libGLESv2/ResourceManager.cpp

@@ -389,7 +389,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
         }
         else if (type == TEXTURE_2D_ARRAY)
         {
-            textureObject = new Texture2DArray(mRenderer, texture);
+            textureObject = new Texture2DArray(mRenderer->createTexture2DArray(), texture);
         }
         else
         {

src/libGLESv2/Texture.h

@@ -27,13 +27,11 @@ class Surface;
 
 namespace rx
 {
-class Renderer;
 class Texture2DImpl;
 class TextureCubeImpl;
 class Texture3DImpl;
+class Texture2DArrayImpl;
 class TextureStorageInterface;
-class TextureStorageInterface3D;
-class TextureStorageInterface2DArray;
 class RenderTarget;
 class Image;
 }
@@ -43,8 +41,6 @@ namespace gl
 class Framebuffer;
 class FramebufferAttachment;
 
-bool IsMipmapFiltered(const SamplerState &samplerState);
-
 class Texture : public RefCountObject
 {
   public:
@@ -98,44 +94,6 @@ class Texture : public RefCountObject
     virtual const rx::Image *getBaseLevelImage() const = 0;
 };
 
-// TODO: This class is only here to make incremental Texture refactoring easier
-class TextureWithRenderer : public Texture
-{
-  public:
-    TextureWithRenderer(rx::Renderer *renderer, GLuint id, GLenum target);
-    virtual ~TextureWithRenderer();
-
-    virtual rx::TextureStorageInterface *getNativeTexture();
-
-    virtual bool hasDirtyImages() const;
-    virtual void resetDirty();
-
-  protected:
-    void setImage(const PixelUnpackState &unpack, GLenum type, const void *pixels, rx::Image *image);
-    bool subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
-                  GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels, rx::Image *image);
-    void setCompressedImage(GLsizei imageSize, const void *pixels, rx::Image *image);
-    bool subImageCompressed(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
-                            GLenum format, GLsizei imageSize, const void *pixels, rx::Image *image);
-    bool isFastUnpackable(const PixelUnpackState &unpack, GLenum sizedInternalFormat);
-    bool fastUnpackPixels(const PixelUnpackState &unpack, const void *pixels, const Box &destArea,
-                          GLenum sizedInternalFormat, GLenum type, rx::RenderTarget *destRenderTarget);
-
-    GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
-
-    virtual void initializeStorage(bool renderTarget) = 0;
-    virtual void updateStorage() = 0;
-    virtual bool ensureRenderTarget() = 0;
-
-    rx::Renderer *mRenderer;
-    bool mDirtyImages;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(TextureWithRenderer);
-
-    virtual rx::TextureStorageInterface *getBaseLevelStorage() = 0;
-};
-
 class Texture2D : public Texture
 {
   public:
@@ -289,13 +247,18 @@ class Texture3D : public Texture
     rx::Texture3DImpl *mTexture;
 };
 
-class Texture2DArray : public TextureWithRenderer
+class Texture2DArray : public Texture
 {
   public:
-    Texture2DArray(rx::Renderer *renderer, GLuint id);
+    Texture2DArray(rx::Texture2DArrayImpl *impl, GLuint id);
 
     ~Texture2DArray();
 
+    virtual rx::TextureStorageInterface *getNativeTexture();
+    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const;
+    virtual void resetDirty();
+
     GLsizei getWidth(GLint level) const;
     GLsizei getHeight(GLint level) const;
     GLsizei getLayers(GLint level) const;
@@ -326,32 +289,9 @@ class Texture2DArray : public TextureWithRenderer
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture2DArray);
 
-    virtual void initializeStorage(bool renderTarget);
-    rx::TextureStorageInterface2DArray *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(rx::TextureStorageInterface2DArray *newCompleteTexStorage);
-
-    virtual void updateStorage();
-    virtual bool ensureRenderTarget();
-
-    virtual rx::TextureStorageInterface *getBaseLevelStorage();
     virtual const rx::Image *getBaseLevelImage() const;
 
-    void deleteImages();
-    void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height);
-
-    bool isValidLevel(int level) const;
-    bool isLevelComplete(int level) const;
-    void updateStorageLevel(int level);
-
-    // Storing images as an array of single depth textures since D3D11 treats each array level of a
-    // Texture2D object as a separate subresource.  Each layer would have to be looped over
-    // to update all the texture layers since they cannot all be updated at once and it makes the most
-    // sense for the Image class to not have to worry about layer subresource as well as mip subresources.
-    GLsizei mLayerCounts[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
-    rx::Image **mImageArray[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
-
-    rx::TextureStorageInterface2DArray *mTexStorage;
+    rx::Texture2DArrayImpl *mTexture;
 };
 
 }

src/libGLESv2/renderer/Renderer.h

@@ -60,6 +60,7 @@ class UniformStorage;
 class Texture2DImpl;
 class TextureCubeImpl;
 class Texture3DImpl;
+class Texture2DArrayImpl;
 
 struct ConfigDesc
 {
@@ -232,6 +233,7 @@ class Renderer
     virtual Texture2DImpl *createTexture2D() = 0;
     virtual TextureCubeImpl *createTextureCube() = 0;
     virtual Texture3DImpl *createTexture3D() = 0;
+    virtual Texture2DArrayImpl *createTexture2DArray() = 0;
 
     // Buffer creation
     virtual BufferImpl *createBuffer() = 0;

src/libGLESv2/renderer/TextureImpl.h

@@ -130,6 +130,37 @@ class Texture3DImpl
     virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
 };
 
+class Texture2DArrayImpl
+{
+  public:
+    virtual ~Texture2DArrayImpl() {}
+
+    virtual TextureStorageInterface *getNativeTexture() = 0;
+
+    virtual Image *getImage(int level, int layer) const = 0;
+    virtual GLsizei getLayerCount(int level) const = 0;
+
+    virtual void setUsage(GLenum usage) = 0;
+    virtual bool hasDirtyImages() const = 0;
+    virtual void resetDirty() = 0;
+
+    virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const = 0;
+    virtual bool isMipmapComplete() const = 0;
+
+    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels) = 0;
+    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) = 0;
+    virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 0;
+    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
+    virtual void generateMipmaps() = 0;
+
+    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer) = 0;
+
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer) = 0;
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer) = 0;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTUREIMPL_H_

src/libGLESv2/renderer/d3d/TextureD3D.h

@@ -28,6 +28,9 @@ class TextureStorageInterface;
 class TextureStorageInterface2D;
 class TextureStorageInterfaceCube;
 class TextureStorageInterface3D;
+class TextureStorageInterface2DArray;
+
+bool IsMipmapFiltered(const gl::SamplerState &samplerState);
 
 class TextureD3D
 {
@@ -265,6 +268,76 @@ class TextureD3D_3D : public Texture3DImpl, public TextureD3D
     TextureStorageInterface3D *mTexStorage;
 };
 
+class TextureD3D_2DArray : public Texture2DArrayImpl, public TextureD3D
+{
+  public:
+    TextureD3D_2DArray(Renderer *renderer);
+    virtual ~TextureD3D_2DArray();
+
+    static TextureD3D_2DArray *makeTextureD3D_2DArray(Texture2DArrayImpl *texture);
+
+    virtual TextureStorageInterface *getNativeTexture();
+
+    virtual Image *getImage(int level, int layer) const;
+    virtual GLsizei getLayerCount(int level) const;
+
+    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty();
+
+    GLsizei getWidth(GLint level) const;
+    GLsizei getHeight(GLint level) const;
+    GLsizei getLayers(GLint level) const;
+    GLenum getInternalFormat(GLint level) const;
+    bool isDepth(GLint level) const;
+
+    virtual void setImage(GLint level, GLsizei width, GLsizei height, GLsizei depth, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei depth, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
+    virtual void storage(GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+
+    virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
+    virtual bool isMipmapComplete() const;
+
+    virtual void generateMipmaps();
+
+    virtual unsigned int getRenderTargetSerial(GLint level, GLint layer);
+
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureD3D_2DArray);
+
+    virtual void initializeStorage(bool renderTarget);
+    TextureStorageInterface2DArray *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorageInterface2DArray *newCompleteTexStorage);
+
+    void updateStorage();
+    bool ensureRenderTarget();
+    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual const ImageD3D *getBaseLevelImage() const;
+
+    bool isValidLevel(int level) const;
+    bool isLevelComplete(int level) const;
+    void updateStorageLevel(int level);
+
+    void deleteImages();
+    void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+    void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint layerTarget, GLsizei width, GLsizei height);
+
+    // Storing images as an array of single depth textures since D3D11 treats each array level of a
+    // Texture2D object as a separate subresource.  Each layer would have to be looped over
+    // to update all the texture layers since they cannot all be updated at once and it makes the most
+    // sense for the Image class to not have to worry about layer subresource as well as mip subresources.
+    GLsizei mLayerCounts[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+    ImageD3D **mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+
+    TextureStorageInterface2DArray *mTexStorage;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTURED3D_H_

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

@@ -2925,6 +2925,11 @@ Texture3DImpl *Renderer11::createTexture3D()
     return new TextureD3D_3D(this);
 }
 
+Texture2DArrayImpl *Renderer11::createTexture2DArray()
+{
+    return new TextureD3D_2DArray(this);
+}
+
 void Renderer11::readTextureData(ID3D11Texture2D *texture, unsigned int subResource, const gl::Rectangle &area, GLenum format,
                                  GLenum type, GLuint outputPitch, const gl::PixelPackState &pack, void *pixels)
 {

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

@@ -181,6 +181,7 @@ class Renderer11 : public Renderer
     virtual Texture2DImpl *createTexture2D();
     virtual TextureCubeImpl *createTextureCube();
     virtual Texture3DImpl *createTexture3D();
+    virtual Texture2DArrayImpl *createTexture2DArray();
 
     // Buffer creation
     virtual BufferImpl *createBuffer();

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

@@ -195,7 +195,7 @@ UINT TextureStorage11::getSubresourceIndex(int mipLevel, int layerTarget) const
 ID3D11ShaderResourceView *TextureStorage11::getSRV(const gl::SamplerState &samplerState)
 {
     bool swizzleRequired = samplerState.swizzleRequired();
-    bool mipmapping = gl::IsMipmapFiltered(samplerState);
+    bool mipmapping = IsMipmapFiltered(samplerState);
     unsigned int mipLevels = mipmapping ? (samplerState.maxLevel - samplerState.baseLevel) : 1;
 
     // Make sure there's 'mipLevels' mipmap levels below the base level (offset by the top level,  which corresponds to GL level 0)

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

@@ -3211,6 +3211,11 @@ Texture3DImpl *Renderer9::createTexture3D()
     return new TextureD3D_3D(this);
 }
 
+Texture2DArrayImpl *Renderer9::createTexture2DArray()
+{
+    return new TextureD3D_2DArray(this);
+}
+
 bool Renderer9::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;

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

@@ -183,6 +183,7 @@ class Renderer9 : public Renderer
     virtual Texture2DImpl *createTexture2D();
     virtual TextureCubeImpl *createTextureCube();
     virtual Texture3DImpl *createTexture3D();
+    virtual Texture2DArrayImpl *createTexture2DArray();
 
     // Buffer creation
     virtual BufferImpl *createBuffer();