Refactored TextureCubeMap, separated out D3D logic

src/libGLESv2/Context.cpp

@@ -69,7 +69,7 @@ Context::Context(int clientVersion, const gl::Context *shareContext, rx::Rendere
     // objects all of whose names are 0.
 
     mTexture2DZero.set(new Texture2D(mRenderer->createTexture2D(), 0));
-    mTextureCubeMapZero.set(new TextureCubeMap(mRenderer, 0));
+    mTextureCubeMapZero.set(new TextureCubeMap(mRenderer->createTextureCube(), 0));
     mTexture3DZero.set(new Texture3D(mRenderer, 0));
     mTexture2DArrayZero.set(new Texture2DArray(mRenderer, 0));
 
@@ -2159,7 +2159,7 @@ Texture *Context::getIncompleteTexture(TextureType type)
 
           case TEXTURE_CUBE:
             {
-              TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer, Texture::INCOMPLETE_TEXTURE_ID);
+              TextureCubeMap *incompleteCube = new TextureCubeMap(mRenderer->createTextureCube(), Texture::INCOMPLETE_TEXTURE_ID);
 
               incompleteCube->setImagePosX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
               incompleteCube->setImageNegX(0, 1, 1, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);

src/libGLESv2/ResourceManager.cpp

@@ -381,7 +381,7 @@ void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
         }
         else if (type == TEXTURE_CUBE)
         {
-            textureObject = new TextureCubeMap(mRenderer, texture);
+            textureObject = new TextureCubeMap(mRenderer->createTextureCube(), texture);
         }
         else if (type == TEXTURE_3D)
         {

src/libGLESv2/Texture.h

@@ -29,9 +29,8 @@ namespace rx
 {
 class Renderer;
 class Texture2DImpl;
+class TextureCubeImpl;
 class TextureStorageInterface;
-class TextureStorageInterface2D;
-class TextureStorageInterfaceCube;
 class TextureStorageInterface3D;
 class TextureStorageInterface2DArray;
 class RenderTarget;
@@ -187,13 +186,18 @@ class Texture2D : public Texture
     egl::Surface *mSurface;
 };
 
-class TextureCubeMap : public TextureWithRenderer
+class TextureCubeMap : public Texture
 {
   public:
-    TextureCubeMap(rx::Renderer *renderer, GLuint id);
+    TextureCubeMap(rx::TextureCubeImpl *impl, GLuint id);
 
     ~TextureCubeMap();
 
+    virtual rx::TextureStorageInterface *getNativeTexture();
+    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const;
+    virtual void resetDirty();
+
     GLsizei getWidth(GLenum target, GLint level) const;
     GLsizei getHeight(GLenum target, GLint level) const;
     GLenum getInternalFormat(GLenum target, GLint level) const;
@@ -223,8 +227,6 @@ class TextureCubeMap : public TextureWithRenderer
 
     unsigned int getRenderTargetSerial(GLenum target, GLint level);
 
-    static int targetToIndex(GLenum target);
-
   protected:
     friend class TextureCubeMapAttachment;
     rx::RenderTarget *getRenderTarget(GLenum target, GLint level);
@@ -233,27 +235,9 @@ class TextureCubeMap : public TextureWithRenderer
   private:
     DISALLOW_COPY_AND_ASSIGN(TextureCubeMap);
 
-    virtual void initializeStorage(bool renderTarget);
-    rx::TextureStorageInterfaceCube *createCompleteStorage(bool renderTarget) const;
-    void setCompleteTexStorage(rx::TextureStorageInterfaceCube *newCompleteTexStorage);
-
-    virtual void updateStorage();
-    virtual bool ensureRenderTarget();
-    virtual rx::TextureStorageInterface *getBaseLevelStorage();
     virtual const rx::Image *getBaseLevelImage() const;
 
-    bool isMipmapCubeComplete() const;
-    bool isValidFaceLevel(int faceIndex, int level) const;
-    bool isFaceLevelComplete(int faceIndex, int level) const;
-    void updateStorageFaceLevel(int faceIndex, int level);
-
-    void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const PixelUnpackState &unpack, const void *pixels);
-    void commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
-    void redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height);
-
-    rx::Image *mImageArray[6][IMPLEMENTATION_MAX_TEXTURE_LEVELS];
-
-    rx::TextureStorageInterfaceCube *mTexStorage;
+    rx::TextureCubeImpl *mTexture;
 };
 
 class Texture3D : public TextureWithRenderer

src/libGLESv2/renderer/Renderer.h

@@ -59,6 +59,7 @@ class TextureStorage;
 class UniformStorage;
 
 class Texture2DImpl;
+class TextureCubeImpl;
 
 struct ConfigDesc
 {
@@ -229,6 +230,7 @@ class Renderer
 
     // Texture creation
     virtual Texture2DImpl *createTexture2D() = 0;
+    virtual TextureCubeImpl *createTextureCube() = 0;
 
     // Buffer creation
     virtual BufferImpl *createBuffer() = 0;

src/libGLESv2/renderer/TextureImpl.h

@@ -11,9 +11,15 @@
 
 #include "common/angleutils.h"
 
+namespace egl
+{
+class Surface;
+}
+
 namespace gl
 {
 class Framebuffer;
+struct PixelUnpackState;
 struct SamplerState;
 }
 
@@ -24,7 +30,6 @@ class Image;
 class RenderTarget;
 class Renderer;
 class TextureStorageInterface;
-class TextureStorageInterface2D;
 
 class Texture2DImpl
 {
@@ -63,6 +68,37 @@ class Texture2DImpl
     virtual void redefineImage(GLint level, GLenum internalformat, GLsizei width, GLsizei height) = 0;
 };
 
+class TextureCubeImpl
+{
+  public:
+    virtual ~TextureCubeImpl() {}
+
+    virtual TextureStorageInterface *getNativeTexture() = 0;
+
+    virtual Image *getImage(GLenum target, 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 isCubeComplete() const = 0;
+
+    virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels) = 0;
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels) = 0;
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) = 0;
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source) = 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 size) = 0;
+    virtual void generateMipmaps() = 0;
+
+    virtual unsigned int getRenderTargetSerial(GLenum target, GLint level) = 0;
+
+    virtual RenderTarget *getRenderTarget(GLenum target, GLint level) = 0;
+    virtual RenderTarget *getDepthStencil(GLenum target, GLint level) = 0;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTUREIMPL_H_

src/libGLESv2/renderer/d3d/TextureD3D.h

@@ -26,6 +26,7 @@ class ImageD3D;
 class Renderer;
 class TextureStorageInterface;
 class TextureStorageInterface2D;
+class TextureStorageInterfaceCube;
 
 class TextureD3D
 {
@@ -135,6 +136,70 @@ class TextureD3D_2D : public Texture2DImpl, public TextureD3D
     ImageD3D *mImageArray[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
 };
 
+class TextureD3D_Cube : public TextureCubeImpl, public TextureD3D
+{
+  public:
+    TextureD3D_Cube(rx::Renderer *renderer);
+    virtual ~TextureD3D_Cube();
+
+    static TextureD3D_Cube *makeTextureD3D_Cube(TextureCubeImpl *texture);
+
+    virtual TextureStorageInterface *getNativeTexture();
+
+    virtual Image *getImage(GLenum target, int level) const;
+
+    virtual void setUsage(GLenum usage);
+    virtual bool hasDirtyImages() const { return mDirtyImages; }
+    virtual void resetDirty();
+
+    GLenum getInternalFormat(GLenum target, GLint level) const;
+    bool isDepth(GLenum target, GLint level) const;
+
+    virtual void setImage(int faceIndex, GLint level, GLsizei width, GLsizei height, GLenum internalFormat, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void setCompressedImage(GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
+    virtual void subImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const gl::PixelUnpackState &unpack, const void *pixels);
+    virtual void subImageCompressed(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
+    virtual void copyImage(GLenum target, GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, gl::Framebuffer *source);
+    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 size);
+
+    virtual bool isSamplerComplete(const gl::SamplerState &samplerState) const;
+    virtual bool isCubeComplete() const;
+
+    virtual void generateMipmaps();
+
+    virtual unsigned int getRenderTargetSerial(GLenum target, GLint level);
+
+    virtual RenderTarget *getRenderTarget(GLenum target, GLint level);
+    virtual RenderTarget *getDepthStencil(GLenum target, GLint level);
+
+    static int targetToIndex(GLenum target);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(TextureD3D_Cube);
+
+    void initializeStorage(bool renderTarget);
+    TextureStorageInterfaceCube *createCompleteStorage(bool renderTarget) const;
+    void setCompleteTexStorage(TextureStorageInterfaceCube *newCompleteTexStorage);
+
+    void updateStorage();
+    bool ensureRenderTarget();
+    virtual TextureStorageInterface *getBaseLevelStorage();
+    virtual const ImageD3D *getBaseLevelImage() const;
+
+    bool isMipmapCubeComplete() const;
+    bool isValidFaceLevel(int faceIndex, int level) const;
+    bool isFaceLevelComplete(int faceIndex, int level) const;
+    void updateStorageFaceLevel(int faceIndex, int level);
+
+    void redefineImage(int faceIndex, GLint level, GLenum internalformat, GLsizei width, GLsizei height);
+    void commitRect(int faceIndex, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height);
+
+    ImageD3D *mImageArray[6][gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS];
+
+    TextureStorageInterfaceCube *mTexStorage;
+};
+
 }
 
 #endif // LIBGLESV2_RENDERER_TEXTURED3D_H_

src/libGLESv2/renderer/d3d/TextureStorage.cpp

@@ -10,6 +10,7 @@
 // GPU-side texture.
 
 #include "libGLESv2/renderer/d3d/TextureStorage.h"
+#include "libGLESv2/renderer/d3d/TextureD3D.h"
 #include "libGLESv2/renderer/Renderer.h"
 #include "libGLESv2/Renderbuffer.h"
 #include "libGLESv2/Texture.h"
@@ -116,7 +117,7 @@ void TextureStorageInterfaceCube::generateMipmap(int faceIndex, int level)
 
 unsigned int TextureStorageInterfaceCube::getRenderTargetSerial(GLenum target, GLint level) const
 {
-    return mFirstRenderTargetSerial + (level * 6) + gl::TextureCubeMap::targetToIndex(target);
+    return mFirstRenderTargetSerial + (level * 6) + TextureD3D_Cube::targetToIndex(target);
 }
 
 TextureStorageInterface3D::TextureStorageInterface3D(Renderer *renderer, GLenum internalformat, bool renderTarget,

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

@@ -2906,6 +2906,11 @@ Texture2DImpl *Renderer11::createTexture2D()
     return new TextureD3D_2D(this);
 }
 
+TextureCubeImpl *Renderer11::createTextureCube()
+{
+    return new TextureD3D_Cube(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

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

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

@@ -10,6 +10,7 @@
 
 #include "libGLESv2/renderer/d3d/d3d11/TextureStorage11.h"
 
+#include "libGLESv2/renderer/d3d/TextureD3D.h"
 #include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
 #include "libGLESv2/renderer/d3d/d3d11/RenderTarget11.h"
 #include "libGLESv2/renderer/d3d/d3d11/SwapChain11.h"
@@ -770,7 +771,7 @@ RenderTarget *TextureStorage11_Cube::getRenderTargetFace(GLenum faceTarget, int
 {
     if (level >= 0 && level < getLevelCount())
     {
-        int faceIndex = gl::TextureCubeMap::targetToIndex(faceTarget);
+        int faceIndex = TextureD3D_Cube::targetToIndex(faceTarget);
         if (!mRenderTarget[faceIndex][level])
         {
             ID3D11Device *device = mRenderer->getDevice();

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

@@ -3199,6 +3199,11 @@ Texture2DImpl *Renderer9::createTexture2D()
     return new TextureD3D_2D(this);
 }
 
+TextureCubeImpl *Renderer9::createTextureCube()
+{
+    return new TextureD3D_Cube(this);
+}
+
 bool Renderer9::getLUID(LUID *adapterLuid) const
 {
     adapterLuid->HighPart = 0;

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

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

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

@@ -10,6 +10,7 @@
 // D3D9 texture.
 
 #include "libGLESv2/main.h"
+#include "libGLESv2/renderer/d3d/TextureD3D.h"
 #include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
 #include "libGLESv2/renderer/d3d/d3d9/TextureStorage9.h"
 #include "libGLESv2/renderer/d3d/d3d9/SwapChain9.h"
@@ -264,7 +265,7 @@ IDirect3DSurface9 *TextureStorage9_Cube::getCubeMapSurface(GLenum faceTarget, in
 
 RenderTarget *TextureStorage9_Cube::getRenderTargetFace(GLenum faceTarget, int level)
 {
-    return mRenderTarget[gl::TextureCubeMap::targetToIndex(faceTarget)];
+    return mRenderTarget[TextureD3D_Cube::targetToIndex(faceTarget)];
 }
 
 void TextureStorage9_Cube::generateMipmap(int faceIndex, int level)