Share TextureState structure with TextureImpl

src/libANGLE/ResourceManager_unittest.cpp

@@ -15,6 +15,8 @@
 using namespace rx;
 using namespace gl;
 
+using ::testing::_;
+
 namespace
 {
 
@@ -37,7 +39,7 @@ class ResourceManagerTest : public testing::Test
 
 TEST_F(ResourceManagerTest, ReallocateBoundTexture)
 {
-    EXPECT_CALL(mMockFactory, createTexture(GL_TEXTURE_2D)).Times(1).RetiresOnSaturation();
+    EXPECT_CALL(mMockFactory, createTexture(_)).Times(1).RetiresOnSaturation();
 
     mResourceManager->checkTextureAllocation(1, GL_TEXTURE_2D);
     GLuint newTexture = mResourceManager->createTexture();

src/libANGLE/Texture.h

@@ -42,6 +42,38 @@ class Framebuffer;
 
 bool IsMipmapFiltered(const SamplerState &samplerState);
 
+// State from Table 6.9 (state per texture object) in the OpenGL ES 3.0.2 spec.
+struct TextureState final : public angle::NonCopyable
+{
+    TextureState(GLenum target);
+
+    bool swizzleRequired() const;
+    GLuint getEffectiveBaseLevel() const;
+
+    // TODO(jmadill): Make the data members here private.
+
+    const GLenum target;
+
+    GLenum swizzleRed;
+    GLenum swizzleGreen;
+    GLenum swizzleBlue;
+    GLenum swizzleAlpha;
+
+    SamplerState samplerState;
+
+    GLuint baseLevel;
+    GLuint maxLevel;
+
+    bool immutableFormat;
+    GLuint immutableLevels;
+
+    // From GL_ANGLE_texture_usage
+    GLenum usage;
+};
+
+bool operator==(const TextureState &a, const TextureState &b);
+bool operator!=(const TextureState &a, const TextureState &b);
+
 class Texture final : public egl::ImageSibling,
                       public FramebufferAttachmentObject,
                       public LabeledObject
@@ -101,8 +133,6 @@ class Texture final : public egl::ImageSibling,
 
     void setBaseLevel(GLuint baseLevel);
     GLuint getBaseLevel() const;
-    // Returns base level after clamping required for immutable textures.
-    GLuint getEffectiveBaseLevel() const;
 
     void setMaxLevel(GLuint maxLevel);
     GLuint getMaxLevel() const;
@@ -204,15 +234,11 @@ class Texture final : public egl::ImageSibling,
     void acquireImageFromStream(const egl::Stream::GLTextureDescription &desc);
     void releaseImageFromStream();
 
+    TextureState mState;
     rx::TextureImpl *mTexture;
 
     std::string mLabel;
 
-    TextureState mTextureState;
-    GLuint mEffectiveBaseLevel;
-
-    GLenum mTarget;
-
     struct ImageDesc
     {
         Extents size;
@@ -236,8 +262,6 @@ class Texture final : public egl::ImageSibling,
     void clearImageDescs();
     void releaseTexImageInternal();
 
-    void updateEffectiveBaseLevel();
-
     std::vector<ImageDesc> mImageDescs;
 
     struct SamplerCompletenessCache
@@ -262,6 +286,19 @@ class Texture final : public egl::ImageSibling,
     egl::Stream *mBoundStream;
 };
 
+inline bool operator==(const TextureState &a, const TextureState &b)
+{
+    return a.swizzleRed == b.swizzleRed && a.swizzleGreen == b.swizzleGreen &&
+           a.swizzleBlue == b.swizzleBlue && a.swizzleAlpha == b.swizzleAlpha &&
+           a.samplerState == b.samplerState && a.baseLevel == b.baseLevel &&
+           a.maxLevel == b.maxLevel && a.immutableFormat == b.immutableFormat &&
+           a.immutableLevels == b.immutableLevels && a.usage == b.usage;
+}
+
+inline bool operator!=(const TextureState &a, const TextureState &b)
+{
+    return !(a == b);
+}
 }
 
 #endif   // LIBANGLE_TEXTURE_H_

src/libANGLE/angletypes.cpp

@@ -53,26 +53,6 @@ SamplerState::SamplerState()
 {
 }
 
-TextureState::TextureState()
-    : swizzleRed(GL_RED),
-      swizzleGreen(GL_GREEN),
-      swizzleBlue(GL_BLUE),
-      swizzleAlpha(GL_ALPHA),
-      samplerState(),
-      baseLevel(0),
-      maxLevel(1000),
-      immutableFormat(false),
-      immutableLevels(0),
-      usage(GL_NONE)
-{
-}
-
-bool TextureState::swizzleRequired() const
-{
-    return swizzleRed != GL_RED || swizzleGreen != GL_GREEN ||
-           swizzleBlue != GL_BLUE || swizzleAlpha != GL_ALPHA;
-}
-
 static void MinMax(int a, int b, int *minimum, int *maximum)
 {
     if (a < b)

src/libANGLE/angletypes.h

@@ -215,33 +215,6 @@ struct SamplerState
 bool operator==(const SamplerState &a, const SamplerState &b);
 bool operator!=(const SamplerState &a, const SamplerState &b);
 
-// State from Table 6.9 (state per texture object) in the OpenGL ES 3.0.2 spec.
-struct TextureState
-{
-    TextureState();
-
-    GLenum swizzleRed;
-    GLenum swizzleGreen;
-    GLenum swizzleBlue;
-    GLenum swizzleAlpha;
-
-    SamplerState samplerState;
-
-    GLuint baseLevel;
-    GLuint maxLevel;
-
-    bool immutableFormat;
-    GLuint immutableLevels;
-
-    // From GL_ANGLE_texture_usage
-    GLenum usage;
-
-    bool swizzleRequired() const;
-};
-
-bool operator==(const TextureState &a, const TextureState &b);
-bool operator!=(const TextureState &a, const TextureState &b);
-
 struct PixelUnpackState
 {
     BindingPointer<Buffer> pixelBuffer;

src/libANGLE/angletypes.inl

@@ -56,23 +56,4 @@ inline bool operator!=(const SamplerState &a, const SamplerState &b)
     return !(a == b);
 }
 
-inline bool operator==(const TextureState &a, const TextureState &b)
-{
-    return a.swizzleRed == b.swizzleRed &&
-           a.swizzleGreen == b.swizzleGreen &&
-           a.swizzleBlue == b.swizzleBlue &&
-           a.swizzleAlpha == b.swizzleAlpha &&
-           a.samplerState == b.samplerState &&
-           a.baseLevel == b.baseLevel &&
-           a.maxLevel == b.maxLevel &&
-           a.immutableFormat == b.immutableFormat &&
-           a.immutableLevels == b.immutableLevels &&
-           a.usage == b.usage;
-}
-
-inline bool operator!=(const TextureState &a, const TextureState &b)
-{
-    return !(a == b);
-}
-
 }

src/libANGLE/renderer/GLImplFactory.h

@@ -55,7 +55,7 @@ class GLImplFactory : angle::NonCopyable
     virtual FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) = 0;
 
     // Texture creation
-    virtual TextureImpl *createTexture(GLenum target) = 0;
+    virtual TextureImpl *createTexture(const gl::TextureState &state) = 0;
 
     // Renderbuffer creation
     virtual RenderbufferImpl *createRenderbuffer() = 0;

src/libANGLE/renderer/TextureImpl.h

@@ -41,7 +41,7 @@ namespace rx
 class TextureImpl : public FramebufferAttachmentObjectImpl
 {
   public:
-    TextureImpl() {}
+    TextureImpl(const gl::TextureState &state) : mState(state) {}
     virtual ~TextureImpl() {}
 
     virtual void setUsage(GLenum usage) = 0;
@@ -69,12 +69,15 @@ class TextureImpl : public FramebufferAttachmentObjectImpl
                                        egl::Stream *stream,
                                        const egl::Stream::GLTextureDescription &desc) = 0;
 
-    virtual gl::Error generateMipmaps(const gl::TextureState &textureState) = 0;
+    virtual gl::Error generateMipmaps() = 0;
 
     virtual void setBaseLevel(GLuint baseLevel) = 0;
 
     virtual void bindTexImage(egl::Surface *surface) = 0;
     virtual void releaseTexImage() = 0;
+
+  protected:
+    const gl::TextureState &mState;
 };
 
 }

src/libANGLE/renderer/TextureImpl_mock.h

@@ -19,6 +19,7 @@ namespace rx
 class MockTextureImpl : public TextureImpl
 {
   public:
+    MockTextureImpl() : TextureImpl(gl::TextureState(GL_TEXTURE_2D)) {}
     virtual ~MockTextureImpl() { destructor(); }
     MOCK_METHOD1(setUsage, void(GLenum));
     MOCK_METHOD8(setImage, gl::Error(GLenum, size_t, GLenum, const gl::Extents &, GLenum, GLenum, const gl::PixelUnpackState &, const uint8_t *));
@@ -31,7 +32,7 @@ class MockTextureImpl : public TextureImpl
     MOCK_METHOD3(setImageExternal,
                  gl::Error(GLenum, egl::Stream *, const egl::Stream::GLTextureDescription &));
     MOCK_METHOD2(setEGLImageTarget, gl::Error(GLenum, egl::Image *));
-    MOCK_METHOD1(generateMipmaps, gl::Error(const gl::TextureState &));
+    MOCK_METHOD0(generateMipmaps, gl::Error());
     MOCK_METHOD1(bindTexImage, void(egl::Surface *));
     MOCK_METHOD0(releaseTexImage, void(void));
 

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -75,8 +75,9 @@ bool IsRenderTargetUsage(GLenum usage)
 
 }
 
-TextureD3D::TextureD3D(RendererD3D *renderer)
-    : mRenderer(renderer),
+TextureD3D::TextureD3D(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureImpl(state),
+      mRenderer(renderer),
       mUsage(GL_NONE),
       mDirtyImages(true),
       mImmutable(false),
@@ -404,7 +405,7 @@ gl::Error TextureD3D::setImageExternal(GLenum target,
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-gl::Error TextureD3D::generateMipmaps(const gl::TextureState &textureState)
+gl::Error TextureD3D::generateMipmaps()
 {
     GLint mipCount = mipLevels();
 
@@ -442,7 +443,7 @@ gl::Error TextureD3D::generateMipmaps(const gl::TextureState &textureState)
         }
 
         // Generate the mipmap chain using the ad-hoc DirectX function.
-        error = mRenderer->generateMipmapsUsingD3D(mTexStorage, textureState);
+        error = mRenderer->generateMipmapsUsingD3D(mTexStorage, mState);
         if (error.isError())
         {
             return error;
@@ -663,8 +664,8 @@ void TextureD3D::setBaseLevel(GLuint baseLevel)
     }
 }
 
-TextureD3D_2D::TextureD3D_2D(RendererD3D *renderer)
-    : TextureD3D(renderer)
+TextureD3D_2D::TextureD3D_2D(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
     mEGLImageTarget = false;
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
@@ -1344,8 +1345,8 @@ void TextureD3D_2D::markAllImagesDirty()
     mDirtyImages = true;
 }
 
-TextureD3D_Cube::TextureD3D_Cube(RendererD3D *renderer)
-    : TextureD3D(renderer)
+TextureD3D_Cube::TextureD3D_Cube(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
     for (int i = 0; i < 6; i++)
     {
@@ -1936,8 +1937,8 @@ void TextureD3D_Cube::markAllImagesDirty()
     mDirtyImages = true;
 }
 
-TextureD3D_3D::TextureD3D_3D(RendererD3D *renderer)
-    : TextureD3D(renderer)
+TextureD3D_3D::TextureD3D_3D(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
     for (int i = 0; i < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++i)
     {
@@ -2522,8 +2523,8 @@ GLint TextureD3D_3D::getLevelZeroDepth() const
     return getBaseLevelDepth() << getBaseLevel();
 }
 
-TextureD3D_2DArray::TextureD3D_2DArray(RendererD3D *renderer)
-    : TextureD3D(renderer)
+TextureD3D_2DArray::TextureD3D_2DArray(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
     for (int level = 0; level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS; ++level)
     {
@@ -3170,7 +3171,8 @@ void TextureD3D_2DArray::markAllImagesDirty()
     mDirtyImages = true;
 }
 
-TextureD3D_External::TextureD3D_External(RendererD3D *renderer) : TextureD3D(renderer)
+TextureD3D_External::TextureD3D_External(const gl::TextureState &state, RendererD3D *renderer)
+    : TextureD3D(state, renderer)
 {
     mImage = renderer->createImage();
 }

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -30,7 +30,7 @@ class TextureStorage;
 class TextureD3D : public TextureImpl
 {
   public:
-    TextureD3D(RendererD3D *renderer);
+    TextureD3D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D();
 
     gl::Error getNativeTexture(TextureStorage **outStorage);
@@ -61,7 +61,7 @@ class TextureD3D : public TextureImpl
     virtual gl::Error setImageExternal(GLenum target,
                                        egl::Stream *stream,
                                        const egl::Stream::GLTextureDescription &desc) override;
-    gl::Error generateMipmaps(const gl::TextureState &textureState) override;
+    gl::Error generateMipmaps() override;
     TextureStorage *getStorage();
     ImageD3D *getBaseLevelImage() const;
 
@@ -135,7 +135,7 @@ class TextureD3D : public TextureImpl
 class TextureD3D_2D : public TextureD3D
 {
   public:
-    TextureD3D_2D(RendererD3D *renderer);
+    TextureD3D_2D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2D();
 
     virtual ImageD3D *getImage(int level, int layer) const;
@@ -204,7 +204,7 @@ class TextureD3D_2D : public TextureD3D
 class TextureD3D_Cube : public TextureD3D
 {
   public:
-    TextureD3D_Cube(RendererD3D *renderer);
+    TextureD3D_Cube(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_Cube();
 
     virtual ImageD3D *getImage(int level, int layer) const;
@@ -271,7 +271,7 @@ class TextureD3D_Cube : public TextureD3D
 class TextureD3D_3D : public TextureD3D
 {
   public:
-    TextureD3D_3D(RendererD3D *renderer);
+    TextureD3D_3D(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_3D();
 
     virtual ImageD3D *getImage(int level, int layer) const;
@@ -337,7 +337,7 @@ class TextureD3D_3D : public TextureD3D
 class TextureD3D_2DArray : public TextureD3D
 {
   public:
-    TextureD3D_2DArray(RendererD3D *renderer);
+    TextureD3D_2DArray(const gl::TextureState &data, RendererD3D *renderer);
     virtual ~TextureD3D_2DArray();
 
     virtual ImageD3D *getImage(int level, int layer) const;
@@ -407,7 +407,7 @@ class TextureD3D_2DArray : public TextureD3D
 class TextureD3D_External : public TextureD3D
 {
   public:
-    TextureD3D_External(RendererD3D *renderer);
+    TextureD3D_External(const gl::TextureState &data, RendererD3D *renderer);
     ~TextureD3D_External() override;
 
     ImageD3D *getImage(const gl::ImageIndex &index) const override;

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

@@ -1296,15 +1296,7 @@ gl::Error Renderer11::setTexture(gl::SamplerType type, int index, gl::Texture *t
 
         TextureStorage11 *storage11 = GetAs<TextureStorage11>(texStorage);
 
-        // Make sure to add the level offset for our tiny compressed texture workaround
-        gl::TextureState textureState = texture->getTextureState();
-        textureState.baseLevel        = texture->getEffectiveBaseLevel() + storage11->getTopLevel();
-
-        error = storage11->getSRV(textureState, &textureSRV);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(storage11->getSRV(texture->getTextureState(), &textureSRV));
 
         // If we get NULL back from getSRV here, something went wrong in the texture class and we're unexpectedly
         // missing the shader resource view
@@ -2413,7 +2405,7 @@ void Renderer11::SamplerMetadataD3D11::initData(unsigned int samplerCount)
 
 void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex, const gl::Texture &texture)
 {
-    unsigned int baseLevel = texture.getEffectiveBaseLevel();
+    unsigned int baseLevel = texture.getTextureState().getEffectiveBaseLevel();
     GLenum internalFormat = texture.getInternalFormat(texture.getTarget(), baseLevel);
     if (mSamplerMetadata[samplerIndex].baseLevel != static_cast<int>(baseLevel))
     {
@@ -3733,18 +3725,22 @@ TextureStorage *Renderer11::createTextureStorage2DArray(GLenum internalformat, b
     return new TextureStorage11_2DArray(this, internalformat, renderTarget, width, height, depth, levels);
 }
 
-TextureImpl *Renderer11::createTexture(GLenum target)
+TextureImpl *Renderer11::createTexture(const gl::TextureState &state)
 {
-    switch(target)
-    {
-      case GL_TEXTURE_2D: return new TextureD3D_2D(this);
-      case GL_TEXTURE_CUBE_MAP: return new TextureD3D_Cube(this);
-      case GL_TEXTURE_3D: return new TextureD3D_3D(this);
-      case GL_TEXTURE_2D_ARRAY: return new TextureD3D_2DArray(this);
-      case GL_TEXTURE_EXTERNAL_OES:
-          return new TextureD3D_External(this);
-      default:
-        UNREACHABLE();
+    switch (state.target)
+    {
+        case GL_TEXTURE_2D:
+            return new TextureD3D_2D(state, this);
+        case GL_TEXTURE_CUBE_MAP:
+            return new TextureD3D_Cube(state, this);
+        case GL_TEXTURE_3D:
+            return new TextureD3D_3D(state, this);
+        case GL_TEXTURE_2D_ARRAY:
+            return new TextureD3D_2DArray(state, this);
+        case GL_TEXTURE_EXTERNAL_OES:
+            return new TextureD3D_External(state, this);
+        default:
+            UNREACHABLE();
     }
 
     return NULL;

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

@@ -230,7 +230,7 @@ class Renderer11 : public RendererD3D
     virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels);
 
     // Texture creation
-    virtual TextureImpl *createTexture(GLenum target);
+    TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
     virtual RenderbufferImpl *createRenderbuffer();

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

@@ -160,6 +160,8 @@ UINT TextureStorage11::getMiscFlags() const
 
 int TextureStorage11::getTopLevel() const
 {
+    // Applying top level is meant to be encapsulated inside TextureStorage11.
+    UNREACHABLE();
     return mTopLevel;
 }
 
@@ -210,13 +212,15 @@ UINT TextureStorage11::getSubresourceIndex(const gl::ImageIndex &index) const
 gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState,
                                    ID3D11ShaderResourceView **outSRV)
 {
+    // Make sure to add the level offset for our tiny compressed texture workaround
+    const GLuint effectiveBaseLevel = textureState.getEffectiveBaseLevel();
     bool swizzleRequired   = textureState.swizzleRequired();
     bool mipmapping        = gl::IsMipmapFiltered(textureState.samplerState);
-    unsigned int mipLevels = mipmapping ? (textureState.maxLevel - textureState.baseLevel + 1) : 1;
+    unsigned int mipLevels          = mipmapping ? (textureState.maxLevel - effectiveBaseLevel + 1) : 1;
 
     // Make sure there's 'mipLevels' mipmap levels below the base level (offset by the top level,
     // which corresponds to GL level 0)
-    mipLevels = std::min(mipLevels, mMipLevels - mTopLevel - textureState.baseLevel);
+    mipLevels = std::min(mipLevels, mMipLevels - mTopLevel - effectiveBaseLevel);
 
     if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
@@ -240,45 +244,41 @@ gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState,
                             textureState.swizzleBlue, textureState.swizzleAlpha);
     }
 
-    SRVKey key(textureState.baseLevel, mipLevels, swizzleRequired);
+    SRVKey key(effectiveBaseLevel, mipLevels, swizzleRequired);
+    ANGLE_TRY(getCachedOrCreateSRV(key, outSRV));
+
+    return gl::NoError();
+}
+
+gl::Error TextureStorage11::getCachedOrCreateSRV(const SRVKey &key,
+                                                 ID3D11ShaderResourceView **outSRV)
+{
     auto iter = mSrvCache.find(key);
     if (iter != mSrvCache.end())
     {
         *outSRV = iter->second;
-        return gl::Error(GL_NO_ERROR);
+        return gl::NoError();
     }
 
     ID3D11Resource *texture = nullptr;
-    if (swizzleRequired)
+    if (key.swizzle)
     {
-        gl::Error error = getSwizzleTexture(&texture);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getSwizzleTexture(&texture));
     }
     else
     {
-        gl::Error error = getResource(&texture);
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(getResource(&texture));
     }
 
     ID3D11ShaderResourceView *srv = nullptr;
     DXGI_FORMAT format =
-        (swizzleRequired ? mSwizzleFormatSet->srvFormat : mTextureFormatSet->srvFormat);
-    gl::Error error = createSRV(textureState.baseLevel, mipLevels, format, texture, &srv);
-    if (error.isError())
-    {
-        return error;
-    }
+        (key.swizzle ? mSwizzleFormatSet->srvFormat : mTextureFormatSet->srvFormat);
+    ANGLE_TRY(createSRV(key.baseLevel, key.mipLevels, format, texture, &srv));
 
     mSrvCache.insert(std::make_pair(key, srv));
     *outSRV = srv;
 
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
 gl::Error TextureStorage11::getSRVLevel(int mipLevel,
@@ -349,31 +349,9 @@ gl::Error TextureStorage11::getSRVLevels(GLint baseLevel,
     }
 
     SRVKey key(baseLevel, mipLevels, false);
-    auto iter = mSrvCache.find(key);
-    if (iter != mSrvCache.end())
-    {
-        *outSRV = iter->second;
-        return gl::Error(GL_NO_ERROR);
-    }
-
-    ID3D11Resource *texture = nullptr;
-    gl::Error error = getResource(&texture);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(getCachedOrCreateSRV(key, outSRV));
 
-    ID3D11ShaderResourceView *srv = nullptr;
-    error = createSRV(baseLevel, mipLevels, mTextureFormatSet->srvFormat, texture, &srv);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    mSrvCache[key] = srv;
-    *outSRV        = srv;
-
-    return gl::Error(GL_NO_ERROR);
+    return gl::NoError();
 }
 
 d3d11::ANGLEFormat TextureStorage11::getANGLEFormat() const

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

@@ -94,6 +94,7 @@ class TextureStorage11 : public TextureStorage
     virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV) = 0;
     gl::Error getSRVLevel(int mipLevel, bool blitSRV, ID3D11ShaderResourceView **outSRV);
 
+    // The baseLevel parameter should *not* have mTopLevel applied.
     virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture,
                                 ID3D11ShaderResourceView **outSRV) const = 0;
 
@@ -138,12 +139,14 @@ class TextureStorage11 : public TextureStorage
 
         bool operator<(const SRVKey &rhs) const;
 
-        int baseLevel;
+        int baseLevel;  // Without mTopLevel applied.
         int mipLevels;
         bool swizzle;
     };
     typedef std::map<SRVKey, ID3D11ShaderResourceView *> SRVCache;
 
+    gl::Error getCachedOrCreateSRV(const SRVKey &key, ID3D11ShaderResourceView **outSRV);
+
     SRVCache mSrvCache;
     std::array<ID3D11ShaderResourceView *, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS> mLevelSRVs;
     std::array<ID3D11ShaderResourceView *, gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS> mLevelBlitSRVs;

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

@@ -2749,13 +2749,16 @@ TextureStorage *Renderer9::createTextureStorage2DArray(GLenum internalformat, bo
     return NULL;
 }
 
-TextureImpl *Renderer9::createTexture(GLenum target)
+TextureImpl *Renderer9::createTexture(const gl::TextureState &state)
 {
-    switch(target)
+    switch (state.target)
     {
-      case GL_TEXTURE_2D:       return new TextureD3D_2D(this);
-      case GL_TEXTURE_CUBE_MAP: return new TextureD3D_Cube(this);
-      default:                  UNREACHABLE();
+        case GL_TEXTURE_2D:
+            return new TextureD3D_2D(state, this);
+        case GL_TEXTURE_CUBE_MAP:
+            return new TextureD3D_Cube(state, this);
+        default:
+            UNREACHABLE();
     }
 
     return NULL;

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

@@ -225,7 +225,7 @@ class Renderer9 : public RendererD3D
     virtual TextureStorage *createTextureStorage2DArray(GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, GLsizei depth, int levels);
 
     // Texture creation
-    virtual TextureImpl *createTexture(GLenum target);
+    TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
     virtual RenderbufferImpl *createRenderbuffer();

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -288,9 +288,9 @@ FramebufferImpl *RendererGL::createFramebuffer(const gl::FramebufferState &data)
     return new FramebufferGL(data, mFunctions, mStateManager, mWorkarounds, false);
 }
 
-TextureImpl *RendererGL::createTexture(GLenum target)
+TextureImpl *RendererGL::createTexture(const gl::TextureState &state)
 {
-    return new TextureGL(target, mFunctions, mWorkarounds, mStateManager, mBlitter);
+    return new TextureGL(state, mFunctions, mWorkarounds, mStateManager, mBlitter);
 }
 
 RenderbufferImpl *RendererGL::createRenderbuffer()

src/libANGLE/renderer/gl/RendererGL.h

@@ -71,7 +71,7 @@ class RendererGL : public Renderer
     FramebufferImpl *createFramebuffer(const gl::FramebufferState &data) override;
 
     // Texture creation
-    TextureImpl *createTexture(GLenum target) override;
+    TextureImpl *createTexture(const gl::TextureState &state) override;
 
     // Renderbuffer creation
     RenderbufferImpl *createRenderbuffer() override;

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -730,8 +730,7 @@ gl::Error StateManagerGL::setGenericDrawState(const gl::ContextState &data)
                     bindTexture(textureType, textureGL->getTextureID());
                 }
 
-                textureGL->syncState(textureUnitIndex, texture->getTextureState(),
-                                     texture->getEffectiveBaseLevel());
+                textureGL->syncState(textureUnitIndex);
             }
             else
             {

src/libANGLE/renderer/gl/TextureGL.h

@@ -11,6 +11,7 @@
 
 #include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/TextureImpl.h"
+#include "libANGLE/Texture.h"
 
 namespace rx
 {
@@ -51,7 +52,7 @@ struct LevelInfoGL
 class TextureGL : public TextureImpl
 {
   public:
-    TextureGL(GLenum type,
+    TextureGL(const gl::TextureState &state,
               const FunctionsGL *functions,
               const WorkaroundsGL &workarounds,
               StateManagerGL *stateManager,
@@ -81,16 +82,14 @@ class TextureGL : public TextureImpl
                                egl::Stream *stream,
                                const egl::Stream::GLTextureDescription &desc) override;
 
-    gl::Error generateMipmaps(const gl::TextureState &textureState) override;
+    gl::Error generateMipmaps() override;
 
     void bindTexImage(egl::Surface *surface) override;
     void releaseTexImage() override;
 
     gl::Error setEGLImageTarget(GLenum target, egl::Image *image) override;
 
-    void syncState(size_t textureUnit,
-                   const gl::TextureState &textureState,
-                   const GLuint effectiveBaseLevel) const;
+    void syncState(size_t textureUnit) const;
     GLuint getTextureID() const;
 
     gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
@@ -102,8 +101,6 @@ class TextureGL : public TextureImpl
     void setBaseLevel(GLuint) override {}
 
   private:
-    GLenum mTextureType;
-
     const FunctionsGL *mFunctions;
     const WorkaroundsGL &mWorkarounds;
     StateManagerGL *mStateManager;

src/tests/angle_unittests_utils.h

@@ -34,7 +34,7 @@ class NullFactory : public GLImplFactory
     }
 
     // Texture creation
-    TextureImpl *createTexture(GLenum target) override { return nullptr; }
+    TextureImpl *createTexture(const gl::TextureState &data) override { return nullptr; }
 
     // Renderbuffer creation
     RenderbufferImpl *createRenderbuffer() override { return nullptr; }
@@ -69,7 +69,7 @@ class MockGLFactory : public GLImplFactory
     MOCK_METHOD1(createShader, ShaderImpl *(const gl::ShaderState &));
     MOCK_METHOD1(createProgram, ProgramImpl *(const gl::ProgramState &));
     MOCK_METHOD1(createFramebuffer, FramebufferImpl *(const gl::FramebufferState &));
-    MOCK_METHOD1(createTexture, TextureImpl *(GLenum target));
+    MOCK_METHOD1(createTexture, TextureImpl *(const gl::TextureState &));
     MOCK_METHOD0(createRenderbuffer, RenderbufferImpl *());
     MOCK_METHOD0(createBuffer, BufferImpl *());
     MOCK_METHOD1(createVertexArray, VertexArrayImpl *(const gl::VertexArrayState &));