Add top-level state sync for Samplers.

src/libANGLE/Context.cpp

@@ -2356,6 +2356,7 @@ void Context::samplerParameteri(GLuint sampler, GLenum pname, GLint param)
     Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     SetSamplerParameteri(samplerObject, pname, param);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::samplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
@@ -2363,6 +2364,7 @@ void Context::samplerParameteriv(GLuint sampler, GLenum pname, const GLint *para
     Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     SetSamplerParameteriv(samplerObject, pname, param);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
@@ -2370,6 +2372,7 @@ void Context::samplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
     Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     SetSamplerParameterf(samplerObject, pname, param);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::samplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
@@ -2377,6 +2380,7 @@ void Context::samplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *pa
     Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     SetSamplerParameterfv(samplerObject, pname, param);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::getSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
@@ -2384,6 +2388,7 @@ void Context::getSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
     const Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     QuerySamplerParameteriv(samplerObject, pname, params);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::getSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
@@ -2391,6 +2396,7 @@ void Context::getSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *param
     const Sampler *samplerObject =
         mState.mSamplers->checkSamplerAllocation(mImplementation.get(), sampler);
     QuerySamplerParameterfv(samplerObject, pname, params);
+    mGLState.setObjectDirty(GL_SAMPLER);
 }
 
 void Context::programParameteri(GLuint program, GLenum pname, GLint value)

src/libANGLE/Sampler.cpp

@@ -16,7 +16,7 @@ namespace gl
 {
 
 Sampler::Sampler(rx::GLImplFactory *factory, GLuint id)
-    : RefCountObject(id), mImpl(factory->createSampler()), mLabel(), mSamplerState()
+    : RefCountObject(id), mState(), mImpl(factory->createSampler(mState)), mLabel()
 {
 }
 
@@ -37,117 +37,117 @@ const std::string &Sampler::getLabel() const
 
 void Sampler::setMinFilter(GLenum minFilter)
 {
-    mSamplerState.minFilter = minFilter;
+    mState.minFilter = minFilter;
 }
 
 GLenum Sampler::getMinFilter() const
 {
-    return mSamplerState.minFilter;
+    return mState.minFilter;
 }
 
 void Sampler::setMagFilter(GLenum magFilter)
 {
-    mSamplerState.magFilter = magFilter;
+    mState.magFilter = magFilter;
 }
 
 GLenum Sampler::getMagFilter() const
 {
-    return mSamplerState.magFilter;
+    return mState.magFilter;
 }
 
 void Sampler::setWrapS(GLenum wrapS)
 {
-    mSamplerState.wrapS = wrapS;
+    mState.wrapS = wrapS;
 }
 
 GLenum Sampler::getWrapS() const
 {
-    return mSamplerState.wrapS;
+    return mState.wrapS;
 }
 
 void Sampler::setWrapT(GLenum wrapT)
 {
-    mSamplerState.wrapT = wrapT;
+    mState.wrapT = wrapT;
 }
 
 GLenum Sampler::getWrapT() const
 {
-    return mSamplerState.wrapT;
+    return mState.wrapT;
 }
 
 void Sampler::setWrapR(GLenum wrapR)
 {
-    mSamplerState.wrapR = wrapR;
+    mState.wrapR = wrapR;
 }
 
 GLenum Sampler::getWrapR() const
 {
-    return mSamplerState.wrapR;
+    return mState.wrapR;
 }
 
 void Sampler::setMaxAnisotropy(float maxAnisotropy)
 {
-    mSamplerState.maxAnisotropy = maxAnisotropy;
+    mState.maxAnisotropy = maxAnisotropy;
 }
 
 float Sampler::getMaxAnisotropy() const
 {
-    return mSamplerState.maxAnisotropy;
+    return mState.maxAnisotropy;
 }
 
 void Sampler::setMinLod(GLfloat minLod)
 {
-    mSamplerState.minLod = minLod;
+    mState.minLod = minLod;
 }
 
 GLfloat Sampler::getMinLod() const
 {
-    return mSamplerState.minLod;
+    return mState.minLod;
 }
 
 void Sampler::setMaxLod(GLfloat maxLod)
 {
-    mSamplerState.maxLod = maxLod;
+    mState.maxLod = maxLod;
 }
 
 GLfloat Sampler::getMaxLod() const
 {
-    return mSamplerState.maxLod;
+    return mState.maxLod;
 }
 
 void Sampler::setCompareMode(GLenum compareMode)
 {
-    mSamplerState.compareMode = compareMode;
+    mState.compareMode = compareMode;
 }
 
 GLenum Sampler::getCompareMode() const
 {
-    return mSamplerState.compareMode;
+    return mState.compareMode;
 }
 
 void Sampler::setCompareFunc(GLenum compareFunc)
 {
-    mSamplerState.compareFunc = compareFunc;
+    mState.compareFunc = compareFunc;
 }
 
 GLenum Sampler::getCompareFunc() const
 {
-    return mSamplerState.compareFunc;
+    return mState.compareFunc;
 }
 
 void Sampler::setSRGBDecode(GLenum sRGBDecode)
 {
-    mSamplerState.sRGBDecode = sRGBDecode;
+    mState.sRGBDecode = sRGBDecode;
 }
 
 GLenum Sampler::getSRGBDecode() const
 {
-    return mSamplerState.sRGBDecode;
+    return mState.sRGBDecode;
 }
 
 const SamplerState &Sampler::getSamplerState() const
 {
-    return mSamplerState;
+    return mState;
 }
 
 rx::SamplerImpl *Sampler::getImplementation() const
@@ -155,4 +155,10 @@ rx::SamplerImpl *Sampler::getImplementation() const
     return mImpl;
 }
 
+void Sampler::syncState(const Context *context)
+{
+    // TODO(jmadill): Use actual dirty bits for sampler.
+    mImpl->syncState(context);
+}
+
 }  // namespace gl

src/libANGLE/Sampler.h

@@ -71,12 +71,13 @@ class Sampler final : public RefCountObject, public LabeledObject
 
     rx::SamplerImpl *getImplementation() const;
 
+    void syncState(const Context *context);
+
   private:
+    SamplerState mState;
     rx::SamplerImpl *mImpl;
 
     std::string mLabel;
-
-    SamplerState mSamplerState;
 };
 
 }  // namespace gl

src/libANGLE/State.cpp

@@ -2177,7 +2177,7 @@ void State::syncDirtyObjects(const Context *context, const DirtyObjects &bitset)
                 break;
             case DIRTY_OBJECT_VERTEX_ARRAY:
                 ASSERT(mVertexArray);
-                mVertexArray->syncImplState(context);
+                mVertexArray->syncState(context);
                 break;
             case DIRTY_OBJECT_PROGRAM_TEXTURES:
                 syncProgramTextures(context);
@@ -2218,16 +2218,15 @@ void State::syncProgramTextures(const Context *context)
         for (GLuint textureUnitIndex : samplerBinding.boundTextureUnits)
         {
             Texture *texture = getSamplerTexture(textureUnitIndex, textureType);
+            Sampler *sampler = getSampler(textureUnitIndex);
 
             if (texture != nullptr)
             {
-                const Sampler *sampler = getSampler(textureUnitIndex);
-
                 // Mark the texture binding bit as dirty if the texture completeness changes.
                 // TODO(jmadill): Use specific dirty bit for completeness change.
                 if (texture->isSamplerComplete(context, sampler))
                 {
-                    texture->syncImplState();
+                    texture->syncState();
                     ASSERT(static_cast<size_t>(textureUnitIndex) < mCompleteTextureCache.size());
                     ASSERT(mCompleteTextureCache[textureUnitIndex] == nullptr ||
                            mCompleteTextureCache[textureUnitIndex] == texture);
@@ -2238,7 +2237,10 @@ void State::syncProgramTextures(const Context *context)
                 mCompleteTextureBindings[textureUnitIndex].bind(texture->getDirtyChannel());
             }
 
-            // TODO(jmadill): Sync sampler state.
+            if (sampler != nullptr)
+            {
+                sampler->syncState(context);
+            }
         }
     }
 }

src/libANGLE/Texture.cpp

@@ -1109,7 +1109,7 @@ Error Texture::generateMipmap(const Context *context)
 
     if (maxLevel > baseLevel)
     {
-        syncImplState();
+        syncState();
         ANGLE_TRY(mTexture->generateMipmap(context));
 
         const ImageDesc &baseImageInfo =
@@ -1264,7 +1264,7 @@ GLuint Texture::getId() const
     return id();
 }
 
-void Texture::syncImplState()
+void Texture::syncState()
 {
     mTexture->syncState(mDirtyBits);
     mDirtyBits.reset();

src/libANGLE/Texture.h

@@ -387,7 +387,7 @@ class Texture final : public egl::ImageSibling,
     };
     using DirtyBits = angle::BitSet<DIRTY_BIT_COUNT>;
 
-    void syncImplState();
+    void syncState();
     bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
 
   private:

src/libANGLE/VertexArray.cpp

@@ -255,7 +255,7 @@ void VertexArray::setElementArrayBuffer(const Context *context, Buffer *buffer)
     mDirtyBits.set(DIRTY_BIT_ELEMENT_ARRAY_BUFFER);
 }
 
-void VertexArray::syncImplState(const Context *context)
+void VertexArray::syncState(const Context *context)
 {
     if (mDirtyBits.any())
     {

src/libANGLE/VertexArray.h

@@ -186,7 +186,7 @@ class VertexArray final : public LabeledObject
 
     static size_t GetVertexIndexFromDirtyBit(size_t dirtyBit);
 
-    void syncImplState(const Context *context);
+    void syncState(const Context *context);
     bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
 
   private:

src/libANGLE/renderer/GLImplFactory.h

@@ -78,7 +78,7 @@ class GLImplFactory : angle::NonCopyable
         const gl::TransformFeedbackState &state) = 0;
 
     // Sampler object creation
-    virtual SamplerImpl *createSampler() = 0;
+    virtual SamplerImpl *createSampler(const gl::SamplerState &state) = 0;
 
     virtual std::vector<PathImpl *> createPaths(GLsizei range) = 0;
 };

src/libANGLE/renderer/SamplerImpl.h

@@ -11,15 +11,29 @@
 
 #include "common/angleutils.h"
 
+namespace gl
+{
+class Context;
+struct SamplerState;
+}  // namespace gl
+
 namespace rx
 {
 
 class SamplerImpl : angle::NonCopyable
 {
   public:
-    SamplerImpl() {}
+    SamplerImpl(const gl::SamplerState &state) : mState(state) {}
     virtual ~SamplerImpl() {}
+
+    virtual void syncState(const gl::Context *context)
+    {
+        // Default implementation: no-op.
+    }
+
+  protected:
+    const gl::SamplerState &mState;
 };
-}
+}  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_SAMPLERIMPL_H_

src/libANGLE/renderer/d3d/SamplerD3D.h

@@ -17,7 +17,7 @@ namespace rx
 class SamplerD3D : public SamplerImpl
 {
   public:
-    SamplerD3D() {}
+    SamplerD3D(const gl::SamplerState &state) : SamplerImpl(state) {}
     ~SamplerD3D() override {}
 };
 }

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

@@ -131,9 +131,9 @@ TransformFeedbackImpl *Context11::createTransformFeedback(const gl::TransformFee
     return new TransformFeedback11(state, mRenderer);
 }
 
-SamplerImpl *Context11::createSampler()
+SamplerImpl *Context11::createSampler(const gl::SamplerState &state)
 {
-    return new SamplerD3D();
+    return new SamplerD3D(state);
 }
 
 std::vector<PathImpl *> Context11::createPaths(GLsizei)

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

@@ -54,7 +54,7 @@ class Context11 : public ContextImpl
         const gl::TransformFeedbackState &state) override;
 
     // Sampler object creation
-    SamplerImpl *createSampler() override;
+    SamplerImpl *createSampler(const gl::SamplerState &state) override;
 
     // Path object creation.
     std::vector<PathImpl *> createPaths(GLsizei) override;

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

@@ -115,9 +115,9 @@ TransformFeedbackImpl *Context9::createTransformFeedback(const gl::TransformFeed
     return nullptr;
 }
 
-SamplerImpl *Context9::createSampler()
+SamplerImpl *Context9::createSampler(const gl::SamplerState &state)
 {
-    return new SamplerD3D();
+    return new SamplerD3D(state);
 }
 
 std::vector<PathImpl *> Context9::createPaths(GLsizei)

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

@@ -54,7 +54,7 @@ class Context9 : public ContextImpl
         const gl::TransformFeedbackState &state) override;
 
     // Sampler object creation
-    SamplerImpl *createSampler() override;
+    SamplerImpl *createSampler(const gl::SamplerState &state) override;
 
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei) override;

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -117,9 +117,9 @@ TransformFeedbackImpl *ContextGL::createTransformFeedback(const gl::TransformFee
     return new TransformFeedbackGL(state, getFunctions(), getStateManager());
 }
 
-SamplerImpl *ContextGL::createSampler()
+SamplerImpl *ContextGL::createSampler(const gl::SamplerState &state)
 {
-    return new SamplerGL(getFunctions(), getStateManager());
+    return new SamplerGL(state, getFunctions(), getStateManager());
 }
 
 std::vector<PathImpl *> ContextGL::createPaths(GLsizei range)

src/libANGLE/renderer/gl/ContextGL.h

@@ -62,7 +62,7 @@ class ContextGL : public ContextImpl
         const gl::TransformFeedbackState &state) override;
 
     // Sampler object creation
-    SamplerImpl *createSampler() override;
+    SamplerImpl *createSampler(const gl::SamplerState &state) override;
 
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei range) override;

src/libANGLE/renderer/gl/SamplerGL.cpp

@@ -33,8 +33,10 @@ static inline void SyncSamplerStateMember(const rx::FunctionsGL *functions,
 namespace rx
 {
 
-SamplerGL::SamplerGL(const FunctionsGL *functions, StateManagerGL *stateManager)
-    : SamplerImpl(),
+SamplerGL::SamplerGL(const gl::SamplerState &state,
+                     const FunctionsGL *functions,
+                     StateManagerGL *stateManager)
+    : SamplerImpl(state),
       mFunctions(functions),
       mStateManager(stateManager),
       mAppliedSamplerState(),
@@ -49,20 +51,20 @@ SamplerGL::~SamplerGL()
     mSamplerID = 0;
 }
 
-void SamplerGL::syncState(const gl::SamplerState &samplerState) const
+void SamplerGL::syncState(const gl::Context *context)
 {
     // clang-format off
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_MIN_FILTER, &gl::SamplerState::minFilter);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_MAG_FILTER, &gl::SamplerState::magFilter);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_WRAP_S, &gl::SamplerState::wrapS);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_WRAP_T, &gl::SamplerState::wrapT);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_WRAP_R, &gl::SamplerState::wrapR);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_MAX_ANISOTROPY_EXT, &gl::SamplerState::maxAnisotropy);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_MIN_LOD, &gl::SamplerState::minLod);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_MAX_LOD, &gl::SamplerState::maxLod);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_COMPARE_MODE, &gl::SamplerState::compareMode);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_COMPARE_FUNC, &gl::SamplerState::compareFunc);
-    SyncSamplerStateMember(mFunctions, mSamplerID, samplerState, mAppliedSamplerState, GL_TEXTURE_SRGB_DECODE_EXT, &gl::SamplerState::sRGBDecode);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_MIN_FILTER, &gl::SamplerState::minFilter);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_MAG_FILTER, &gl::SamplerState::magFilter);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_WRAP_S, &gl::SamplerState::wrapS);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_WRAP_T, &gl::SamplerState::wrapT);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_WRAP_R, &gl::SamplerState::wrapR);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_MAX_ANISOTROPY_EXT, &gl::SamplerState::maxAnisotropy);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_MIN_LOD, &gl::SamplerState::minLod);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_MAX_LOD, &gl::SamplerState::maxLod);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_COMPARE_MODE, &gl::SamplerState::compareMode);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_COMPARE_FUNC, &gl::SamplerState::compareFunc);
+    SyncSamplerStateMember(mFunctions, mSamplerID, mState, mAppliedSamplerState, GL_TEXTURE_SRGB_DECODE_EXT, &gl::SamplerState::sRGBDecode);
     // clang-format on
 }
 

src/libANGLE/renderer/gl/SamplerGL.h

@@ -21,10 +21,12 @@ class StateManagerGL;
 class SamplerGL : public SamplerImpl
 {
   public:
-    SamplerGL(const FunctionsGL *functions, StateManagerGL *stateManager);
+    SamplerGL(const gl::SamplerState &state,
+              const FunctionsGL *functions,
+              StateManagerGL *stateManager);
     ~SamplerGL() override;
 
-    void syncState(const gl::SamplerState &samplerState) const;
+    void syncState(const gl::Context *context) override;
 
     GLuint getSamplerID() const;
 

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -907,8 +907,7 @@ void StateManagerGL::setGenericShaderState(const gl::Context *context)
             const gl::Sampler *sampler = glState.getSampler(textureUnitIndex);
             if (sampler != nullptr)
             {
-                const SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler);
-                samplerGL->syncState(sampler->getSamplerState());
+                SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler);
                 bindSampler(textureUnitIndex, samplerGL->getSamplerID());
             }
             else

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -357,9 +357,9 @@ TransformFeedbackImpl *ContextNULL::createTransformFeedback(const gl::TransformF
     return new TransformFeedbackNULL(state);
 }
 
-SamplerImpl *ContextNULL::createSampler()
+SamplerImpl *ContextNULL::createSampler(const gl::SamplerState &state)
 {
-    return new SamplerNULL();
+    return new SamplerNULL(state);
 }
 
 std::vector<PathImpl *> ContextNULL::createPaths(GLsizei range)

src/libANGLE/renderer/null/ContextNULL.h

@@ -183,7 +183,7 @@ class ContextNULL : public ContextImpl
         const gl::TransformFeedbackState &state) override;
 
     // Sampler object creation
-    SamplerImpl *createSampler() override;
+    SamplerImpl *createSampler(const gl::SamplerState &state) override;
 
     std::vector<PathImpl *> createPaths(GLsizei range) override;
 

src/libANGLE/renderer/null/SamplerNULL.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-SamplerNULL::SamplerNULL() : SamplerImpl()
+SamplerNULL::SamplerNULL(const gl::SamplerState &state) : SamplerImpl(state)
 {
 }
 

src/libANGLE/renderer/null/SamplerNULL.h

@@ -18,7 +18,7 @@ namespace rx
 class SamplerNULL : public SamplerImpl
 {
   public:
-    SamplerNULL();
+    SamplerNULL(const gl::SamplerState &state);
     ~SamplerNULL() override;
 };
 

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -540,9 +540,9 @@ TransformFeedbackImpl *ContextVk::createTransformFeedback(const gl::TransformFee
     return new TransformFeedbackVk(state);
 }
 
-SamplerImpl *ContextVk::createSampler()
+SamplerImpl *ContextVk::createSampler(const gl::SamplerState &state)
 {
-    return new SamplerVk();
+    return new SamplerVk(state);
 }
 
 std::vector<PathImpl *> ContextVk::createPaths(GLsizei)

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -126,7 +126,7 @@ class ContextVk : public ContextImpl, public ResourceVk
         const gl::TransformFeedbackState &state) override;
 
     // Sampler object creation
-    SamplerImpl *createSampler() override;
+    SamplerImpl *createSampler(const gl::SamplerState &state) override;
 
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei) override;

src/libANGLE/renderer/vulkan/SamplerVk.cpp

@@ -14,7 +14,7 @@
 namespace rx
 {
 
-SamplerVk::SamplerVk() : SamplerImpl()
+SamplerVk::SamplerVk(const gl::SamplerState &state) : SamplerImpl(state)
 {
 }
 

src/libANGLE/renderer/vulkan/SamplerVk.h

@@ -18,7 +18,7 @@ namespace rx
 class SamplerVk : public SamplerImpl
 {
   public:
-    SamplerVk();
+    SamplerVk(const gl::SamplerState &state);
     ~SamplerVk() override;
 };
 

src/tests/angle_unittests_utils.h

@@ -61,7 +61,7 @@ class NullFactory : public GLImplFactory
     }
 
     // Sampler object creation
-    SamplerImpl *createSampler() override { return nullptr; }
+    SamplerImpl *createSampler(const gl::SamplerState &state) override { return nullptr; }
 
     std::vector<PathImpl *> createPaths(GLsizei range) override
     {
@@ -87,7 +87,7 @@ class MockGLFactory : public GLImplFactory
     MOCK_METHOD0(createSync, SyncImpl *());
     MOCK_METHOD1(createTransformFeedback,
                  TransformFeedbackImpl *(const gl::TransformFeedbackState &));
-    MOCK_METHOD0(createSampler, SamplerImpl *());
+    MOCK_METHOD1(createSampler, SamplerImpl *(const gl::SamplerState &));
     MOCK_METHOD1(createPaths, std::vector<PathImpl *>(GLsizei));
 };