Refactored Texture3D, separated out D3D logic

src/libGLESv2/Context.cpp

@@ -70,7 +70,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, 0));
+    mTexture3DZero.set(new Texture3D(mRenderer->createTexture3D(), 0));
     mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
 
     bindVertexArray(0);
@@ -2174,7 +2174,7 @@ Texture *Context::getIncompleteTexture(TextureType type)
 
           case TEXTURE_3D:
             {
-                Texture3D *incomplete3d = new Texture3D(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
+                Texture3D *incomplete3d = new Texture3D(mRenderer->createTexture3D(), Texture::INCOMPLETE_TEXTURE_ID);
                 incomplete3d->setImage(0, 1, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
 
                 t = incomplete3d;

src/libGLESv2/ResourceManager.cpp

@@ -385,7 +385,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
         }
         else if (type == TEXTURE_3D)
         {
-            textureObject = new Texture3D(mRenderer, texture);
+            textureObject = new Texture3D(mRenderer->createTexture3D(), texture);
         }
         else if (type == TEXTURE_2D_ARRAY)
         {

src/libGLESv2/Texture.h

@@ -30,6 +30,7 @@ namespace rx
 class Renderer;
 class Texture2DImpl;
 class TextureCubeImpl;
+class Texture3DImpl;
 class TextureStorageInterface;
 class TextureStorageInterface3D;
 class TextureStorageInterface2DArray;
@@ -240,13 +241,18 @@ class TextureCubeMap : public Texture
     rx::TextureCubeImpl *mTexture;
 };
 
-class Texture3D : public TextureWithRenderer
+class Texture3D : public Texture
 {
   public:
-    Texture3D(rx::Renderer *renderer, GLuint id);
+    Texture3D(rx::Texture3DImpl *impl, GLuint id);
 
     ~Texture3D();
 
+    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 getDepth(GLint level) const;
@@ -278,26 +284,9 @@ class Texture3D : public TextureWithRenderer
   private:
     DISALLOW_COPY_AND_ASSIGN(Texture3D);
 
-    virtual void initializeStorage(bool renderTarget);
-    rx::TextureStorageInterface3D *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(rx::TextureStorageInterface3D *newCompleteTexStorage);
-
-    virtual void updateStorage();
-    virtual bool ensureRenderTarget();
-
-    virtual rx::TextureStorageInterface *getBaseLevelStorage();
     virtual const rx::Image *getBaseLevelImage() const;
 
-    void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-
-    bool isValidLevel(int level) const;
-    bool isLevelComplete(int level) const;
-    void updateStorageLevel(int level);
-
-    rx::Image *mImageArray[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
-
-    rx::TextureStorageInterface3D *mTexStorage;
+    rx::Texture3DImpl *mTexture;
 };
 
 class Texture2DArray : public TextureWithRenderer

src/libGLESv2/renderer/Renderer.h

@@ -57,9 +57,9 @@ class RenderTarget;
 class Image;
 class TextureStorage;
 class UniformStorage;
-
 class Texture2DImpl;
 class TextureCubeImpl;
+class Texture3DImpl;
 
 struct ConfigDesc
 {
@@ -231,6 +231,7 @@ class Renderer
     // Texture creation
     virtual Texture2DImpl *createTexture2D() = 0;
     virtual TextureCubeImpl *createTextureCube() = 0;
+    virtual Texture3DImpl *createTexture3D() = 0;
 
     // Buffer creation
     virtual BufferImpl *createBuffer() = 0;

src/libGLESv2/renderer/TextureImpl.h

@@ -99,6 +99,37 @@ class TextureCubeImpl
     virtual RenderTarget *getDepthStencil(GLenum target, GLint level) = 0;
 };
 
+class Texture3DImpl
+{
+  public:
+    virtual ~Texture3DImpl() {}
+
+    virtual TextureStorageInterface *getNativeTexture() = 0;
+
+    virtual Image *getImage(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) = 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

@@ -27,11 +27,12 @@ class Renderer;
 class TextureStorageInterface;
 class TextureStorageInterface2D;
 class TextureStorageInterfaceCube;
+class TextureStorageInterface3D;
 
 class TextureD3D
 {
   public:
-    TextureD3D(rx::Renderer *renderer);
+    TextureD3D(Renderer *renderer);
     virtual ~TextureD3D();
 
     GLint getBaseLevelWidth() const;
@@ -42,15 +43,15 @@ class TextureD3D
     bool isImmutable() const { return mImmutable; }
 
   protected:
-    void setImage(const gl::PixelUnpackState &unpack, GLenum type, const void *pixels, rx::Image *image);
+    void setImage(const gl::PixelUnpackState &unpack, GLenum type, const void *pixels, Image *image);
     bool subImage(GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
-                  GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels, rx::Image *image);
-    void setCompressedImage(GLsizei imageSize, const void *pixels, rx::Image *image);
+                  GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels, Image *image);
+    void setCompressedImage(GLsizei imageSize, const void *pixels, 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);
+                            GLenum format, GLsizei imageSize, const void *pixels, Image *image);
     bool isFastUnpackable(const gl::PixelUnpackState &unpack, GLenum sizedInternalFormat);
     bool fastUnpackPixels(const gl::PixelUnpackState &unpack, const void *pixels, const gl::Box &destArea,
-                                  GLenum sizedInternalFormat, GLenum type, rx::RenderTarget *destRenderTarget);
+                                  GLenum sizedInternalFormat, GLenum type, RenderTarget *destRenderTarget);
 
     GLint creationLevels(GLsizei width, GLsizei height, GLsizei depth) const;
     int mipLevels() const;
@@ -73,7 +74,7 @@ class TextureD3D
 class TextureD3D_2D : public Texture2DImpl, public TextureD3D
 {
   public:
-    TextureD3D_2D(rx::Renderer *renderer);
+    TextureD3D_2D(Renderer *renderer);
     virtual ~TextureD3D_2D();
 
     static TextureD3D_2D *makeTextureD3D_2D(Texture2DImpl *texture);
@@ -139,7 +140,7 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
 class TextureD3D_Cube : public TextureCubeImpl, public TextureD3D
 {
   public:
-    TextureD3D_Cube(rx::Renderer *renderer);
+    TextureD3D_Cube(Renderer *renderer);
     virtual ~TextureD3D_Cube();
 
     static TextureD3D_Cube *makeTextureD3D_Cube(TextureCubeImpl *texture);
@@ -200,6 +201,70 @@ class TextureD3D_Cube : public TextureCubeImpl, public TextureD3D
     TextureStorageInterfaceCube *mTexStorage;
 };
 
+class TextureD3D_3D : public Texture3DImpl, public TextureD3D
+{
+  public:
+    TextureD3D_3D(Renderer *renderer);
+    virtual ~TextureD3D_3D();
+
+    static TextureD3D_3D *makeTextureD3D_3D(Texture3DImpl *texture);
+
+    virtual TextureStorageInterface *getNativeTexture();
+
+    virtual Image *getImage(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 getDepth(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);
+    virtual RenderTarget *getRenderTarget(GLint level, GLint layer);
+    virtual RenderTarget *getDepthStencil(GLint level, GLint layer);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureD3D_3D);
+
+    virtual void initializeStorage(bool renderTarget);
+    TextureStorageInterface3D *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorageInterface3D *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 redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
+    void commitRect(GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
+
+    ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+
+    TextureStorageInterface3D *mTexStorage;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTURED3D_H_

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

@@ -2911,6 +2911,11 @@ TextureCubeImpl *Renderer11::createTextureCube()
     return new TextureD3D_Cube(this);
 }
 
+Texture3DImpl *Renderer11::createTexture3D()
+{
+    return new TextureD3D_3D(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

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

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

@@ -3204,6 +3204,11 @@ TextureCubeImpl *Renderer9::createTextureCube()
     return new TextureD3D_Cube(this);
 }
 
+Texture3DImpl *Renderer9::createTexture3D()
+{
+    return new TextureD3D_3D(this);
+}
+
 bool Renderer9::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;

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

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