Add a SamplerImpl object and implement it for the GL backend.

src/libANGLE/ResourceManager.cpp

@@ -441,7 +441,7 @@ void ResourceManager::checkSamplerAllocation(GLuint sampler)
 {
     if (sampler != 0 && !getSampler(sampler))
     {
-        Sampler *samplerObject = new Sampler(sampler);
+        Sampler *samplerObject = new Sampler(mFactory, sampler);
         mSamplerMap[sampler] = samplerObject;
         samplerObject->addRef();
         // Samplers cannot be created via Bind

src/libANGLE/Sampler.cpp

@@ -9,14 +9,22 @@
 
 #include "libANGLE/Sampler.h"
 #include "libANGLE/angletypes.h"
+#include "libANGLE/renderer/ImplFactory.h"
+#include "libANGLE/renderer/SamplerImpl.h"
 
 namespace gl
 {
 
-Sampler::Sampler(GLuint id) : RefCountObject(id), mSamplerState()
+Sampler::Sampler(rx::ImplFactory *factory, GLuint id)
+    : mImpl(factory->createSampler()), RefCountObject(id), mSamplerState()
 {
 }
 
+Sampler::~Sampler()
+{
+    SafeDelete(mImpl);
+}
+
 void Sampler::setMinFilter(GLenum minFilter)
 {
     mSamplerState.minFilter = minFilter;
@@ -122,4 +130,13 @@ const SamplerState &Sampler::getSamplerState() const
     return mSamplerState;
 }
 
+const rx::SamplerImpl *Sampler::getImplementation() const
+{
+    return mImpl;
+}
+
+rx::SamplerImpl *Sampler::getImplementation()
+{
+    return mImpl;
+}
 }

src/libANGLE/Sampler.h

@@ -13,13 +13,20 @@
 #include "libANGLE/angletypes.h"
 #include "libANGLE/RefCountObject.h"
 
+namespace rx
+{
+class ImplFactory;
+class SamplerImpl;
+}
+
 namespace gl
 {
 
-class Sampler : public RefCountObject
+class Sampler final : public RefCountObject
 {
   public:
-    Sampler(GLuint id);
+    Sampler(rx::ImplFactory *factory, GLuint id);
+    ~Sampler() override;
 
     void setMinFilter(GLenum minFilter);
     GLenum getMinFilter() const;
@@ -53,7 +60,12 @@ class Sampler : public RefCountObject
 
     const SamplerState &getSamplerState() const;
 
+    const rx::SamplerImpl *getImplementation() const;
+    rx::SamplerImpl *getImplementation();
+
   private:
+    rx::SamplerImpl *mImpl;
+
     SamplerState mSamplerState;
 };
 

src/libANGLE/renderer/ImplFactory.h

@@ -25,6 +25,7 @@ class FramebufferImpl;
 class ProgramImpl;
 class QueryImpl;
 class RenderbufferImpl;
+class SamplerImpl;
 class ShaderImpl;
 class TextureImpl;
 class TransformFeedbackImpl;
@@ -63,6 +64,9 @@ class ImplFactory : angle::NonCopyable
 
     // Transform Feedback creation
     virtual TransformFeedbackImpl *createTransformFeedback() = 0;
+
+    // Sampler object creation
+    virtual SamplerImpl *createSampler() = 0;
 };
 
 }

src/libANGLE/renderer/SamplerImpl.h

+//
+// Copyright 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SamplerImpl.h: Defines the abstract rx::SamplerImpl class.
+
+#ifndef LIBANGLE_RENDERER_SAMPLERIMPL_H_
+#define LIBANGLE_RENDERER_SAMPLERIMPL_H_
+
+#include "common/angleutils.h"
+
+namespace rx
+{
+
+class SamplerImpl : public angle::NonCopyable
+{
+  public:
+    SamplerImpl() {}
+    virtual ~SamplerImpl() {}
+};
+}
+
+#endif  // LIBANGLE_RENDERER_SAMPLERIMPL_H_

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -23,6 +23,7 @@
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
+#include "libANGLE/renderer/d3d/SamplerD3D.h"
 
 namespace rx
 {
@@ -73,6 +74,11 @@ CompilerImpl *RendererD3D::createCompiler()
     return new CompilerD3D(getRendererClass());
 }
 
+SamplerImpl *RendererD3D::createSampler()
+{
+    return new SamplerD3D();
+}
+
 gl::Error RendererD3D::drawArrays(const gl::Data &data, GLenum mode, GLint first, GLsizei count)
 {
     return genericDrawArrays(data, mode, first, count, 0);

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -131,6 +131,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     CompilerImpl *createCompiler() override;
 
+    SamplerImpl *createSampler() override;
+
     virtual int getMinorShaderModel() const = 0;
     virtual std::string getShaderModelSuffix() const = 0;
 

src/libANGLE/renderer/d3d/SamplerD3D.h

+//
+// Copyright 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SamplerD3D.h: Defines the rx::SamplerD3D class, an implementation of SamplerImpl.
+
+#ifndef LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_
+#define LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_
+
+#include "libANGLE/renderer/SamplerImpl.h"
+
+namespace rx
+{
+
+class SamplerD3D : public SamplerImpl
+{
+  public:
+    SamplerD3D() {}
+    ~SamplerD3D() override {}
+};
+}
+
+#endif  // LIBANGLE_RENDERER_D3D_SAMPLERD3D_H_

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -24,6 +24,7 @@
 #include "libANGLE/renderer/gl/ProgramGL.h"
 #include "libANGLE/renderer/gl/QueryGL.h"
 #include "libANGLE/renderer/gl/RenderbufferGL.h"
+#include "libANGLE/renderer/gl/SamplerGL.h"
 #include "libANGLE/renderer/gl/ShaderGL.h"
 #include "libANGLE/renderer/gl/StateManagerGL.h"
 #include "libANGLE/renderer/gl/SurfaceGL.h"
@@ -297,6 +298,11 @@ TransformFeedbackImpl *RendererGL::createTransformFeedback()
     return new TransformFeedbackGL();
 }
 
+SamplerImpl *RendererGL::createSampler()
+{
+    return new SamplerGL(mFunctions, mStateManager);
+}
+
 void RendererGL::insertEventMarker(GLsizei, const char *)
 {
     UNREACHABLE();

src/libANGLE/renderer/gl/RendererGL.h

@@ -85,6 +85,9 @@ class RendererGL : public Renderer
     // Transform Feedback creation
     TransformFeedbackImpl *createTransformFeedback() override;
 
+    // Sampler object creation
+    SamplerImpl *createSampler() override;
+
     // EXT_debug_marker
     void insertEventMarker(GLsizei length, const char *marker) override;
     void pushGroupMarker(GLsizei length, const char *marker) override;

src/libANGLE/renderer/gl/SamplerGL.cpp

+//
+// Copyright 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SamplerGL.cpp: Defines the rx::SamplerGL class, an implementation of SamplerImpl.
+
+#include "libANGLE/renderer/gl/SamplerGL.h"
+
+#include "libANGLE/renderer/gl/FunctionsGL.h"
+#include "libANGLE/renderer/gl/StateManagerGL.h"
+
+namespace
+{
+
+template <typename T>
+static inline void SyncSamplerStateMember(const rx::FunctionsGL *functions,
+                                          GLuint sampler,
+                                          const gl::SamplerState &newState,
+                                          gl::SamplerState &curState,
+                                          GLenum name,
+                                          T(gl::SamplerState::*samplerMember))
+{
+    if (curState.*samplerMember != newState.*samplerMember)
+    {
+        curState.*samplerMember = newState.*samplerMember;
+        functions->samplerParameterf(sampler, name, static_cast<GLfloat>(curState.*samplerMember));
+    }
+}
+}
+
+namespace rx
+{
+
+SamplerGL::SamplerGL(const FunctionsGL *functions, StateManagerGL *stateManager)
+    : SamplerImpl(),
+      mFunctions(functions),
+      mStateManager(stateManager),
+      mAppliedSamplerState(),
+      mSamplerID(0)
+{
+    mFunctions->genSamplers(1, &mSamplerID);
+}
+
+SamplerGL::~SamplerGL()
+{
+    mStateManager->deleteSampler(mSamplerID);
+    mSamplerID = 0;
+}
+
+void SamplerGL::syncState(const gl::SamplerState &samplerState) const
+{
+    // 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);
+    // clang-format on
+}
+
+GLuint SamplerGL::getSamplerID() const
+{
+    return mSamplerID;
+}
+}

src/libANGLE/renderer/gl/SamplerGL.h

+//
+// Copyright 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// SamplerGL.h: Defines the rx::SamplerGL class, an implementation of SamplerImpl.
+
+#ifndef LIBANGLE_RENDERER_GL_SAMPLERGL_H_
+#define LIBANGLE_RENDERER_GL_SAMPLERGL_H_
+
+#include "libANGLE/angletypes.h"
+#include "libANGLE/renderer/SamplerImpl.h"
+
+namespace rx
+{
+
+class FunctionsGL;
+class StateManagerGL;
+
+class SamplerGL : public SamplerImpl
+{
+  public:
+    SamplerGL(const FunctionsGL *functions, StateManagerGL *stateManager);
+    ~SamplerGL() override;
+
+    void syncState(const gl::SamplerState &samplerState) const;
+
+    GLuint getSamplerID() const;
+
+  private:
+    const FunctionsGL *mFunctions;
+    StateManagerGL *mStateManager;
+
+    mutable gl::SamplerState mAppliedSamplerState;
+    GLuint mSamplerID;
+};
+}
+
+#endif  // LIBANGLE_RENDERER_GL_SAMPLERGL_H_

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -16,6 +16,7 @@
 #include "libANGLE/renderer/gl/FramebufferGL.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 #include "libANGLE/renderer/gl/ProgramGL.h"
+#include "libANGLE/renderer/gl/SamplerGL.h"
 #include "libANGLE/renderer/gl/TextureGL.h"
 #include "libANGLE/renderer/gl/VertexArrayGL.h"
 
@@ -29,6 +30,7 @@ StateManagerGL::StateManagerGL(const FunctionsGL *functions, const gl::Caps &ren
       mBuffers(),
       mTextureUnitIndex(0),
       mTextures(),
+      mSamplers(rendererCaps.maxCombinedTextureImageUnits, 0),
       mUnpackAlignment(4),
       mUnpackRowLength(0),
       mUnpackSkipRows(0),
@@ -161,6 +163,23 @@ void StateManagerGL::deleteTexture(GLuint texture)
         mFunctions->deleteTextures(1, &texture);
     }
 }
+
+void StateManagerGL::deleteSampler(GLuint sampler)
+{
+    if (sampler != 0)
+    {
+        for (size_t unit = 0; unit < mSamplers.size(); unit++)
+        {
+            if (mSamplers[unit] == sampler)
+            {
+                bindSampler(unit, 0);
+            }
+        }
+
+        mFunctions->deleteSamplers(1, &sampler);
+    }
+}
+
 void StateManagerGL::deleteBuffer(GLuint buffer)
 {
     if (buffer != 0)
@@ -253,6 +272,15 @@ void StateManagerGL::bindTexture(GLenum type, GLuint texture)
     }
 }
 
+void StateManagerGL::bindSampler(size_t unit, GLuint sampler)
+{
+    if (mSamplers[unit] != sampler)
+    {
+        mSamplers[unit] = sampler;
+        mFunctions->bindSampler(static_cast<GLuint>(unit), sampler);
+    }
+}
+
 void StateManagerGL::setPixelUnpackState(const gl::PixelUnpackState &unpack)
 {
     GLuint unpackBufferID          = 0;
@@ -487,8 +515,6 @@ gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data)
                 }
 
                 textureGL->syncState(textureUnitIndex, texture->getTextureState());
-
-                // TODO: apply sampler object if one is bound
             }
             else
             {
@@ -498,6 +524,18 @@ gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data)
                     bindTexture(textureType, 0);
                 }
             }
+
+            const gl::Sampler *sampler = state.getSampler(textureUnitIndex);
+            if (sampler != nullptr)
+            {
+                const SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler);
+                samplerGL->syncState(sampler->getSamplerState());
+                bindSampler(textureUnitIndex, samplerGL->getSamplerID());
+            }
+            else
+            {
+                bindSampler(textureUnitIndex, 0);
+            }
         }
     }
 

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -37,6 +37,7 @@ class StateManagerGL final : angle::NonCopyable
     void deleteProgram(GLuint program);
     void deleteVertexArray(GLuint vao);
     void deleteTexture(GLuint texture);
+    void deleteSampler(GLuint sampler);
     void deleteBuffer(GLuint buffer);
     void deleteFramebuffer(GLuint fbo);
     void deleteRenderbuffer(GLuint rbo);
@@ -46,6 +47,7 @@ class StateManagerGL final : angle::NonCopyable
     void bindBuffer(GLenum type, GLuint buffer);
     void activeTexture(size_t unit);
     void bindTexture(GLenum type, GLuint texture);
+    void bindSampler(size_t unit, GLuint sampler);
     void bindFramebuffer(GLenum type, GLuint framebuffer);
     void bindRenderbuffer(GLenum type, GLuint renderbuffer);
 
@@ -138,6 +140,7 @@ class StateManagerGL final : angle::NonCopyable
 
     size_t mTextureUnitIndex;
     std::map<GLenum, std::vector<GLuint>> mTextures;
+    std::vector<GLuint> mSamplers;
 
     GLint mUnpackAlignment;
     GLint mUnpackRowLength;

src/libGLESv2.gypi

@@ -146,6 +146,7 @@
             'libANGLE/renderer/RenderbufferImpl.h',
             'libANGLE/renderer/Renderer.cpp',
             'libANGLE/renderer/Renderer.h',
+            'libANGLE/renderer/SamplerImpl.h',
             'libANGLE/renderer/ShaderImpl.h',
             'libANGLE/renderer/SurfaceImpl.cpp',
             'libANGLE/renderer/SurfaceImpl.h',
@@ -207,6 +208,7 @@
             'libANGLE/renderer/d3d/RendererD3D.h',
             'libANGLE/renderer/d3d/RenderTargetD3D.h',
             'libANGLE/renderer/d3d/RenderTargetD3D.cpp',
+            'libANGLE/renderer/d3d/SamplerD3D.h',
             'libANGLE/renderer/d3d/ShaderD3D.cpp',
             'libANGLE/renderer/d3d/ShaderD3D.h',
             'libANGLE/renderer/d3d/ShaderExecutableD3D.cpp',
@@ -414,6 +416,8 @@
             'libANGLE/renderer/gl/RenderbufferGL.h',
             'libANGLE/renderer/gl/RendererGL.cpp',
             'libANGLE/renderer/gl/RendererGL.h',
+            'libANGLE/renderer/gl/SamplerGL.cpp',
+            'libANGLE/renderer/gl/SamplerGL.h',
             'libANGLE/renderer/gl/ShaderGL.cpp',
             'libANGLE/renderer/gl/ShaderGL.h',
             'libANGLE/renderer/gl/StateManagerGL.cpp',

src/tests/angle_unittests_utils.h

@@ -47,6 +47,9 @@ class NullFactory : public ImplFactory
 
     // Transform Feedback creation
     TransformFeedbackImpl *createTransformFeedback() override { return nullptr; }
+
+    // Sampler object creation
+    SamplerImpl *createSampler() override { return nullptr; }
 };
 
 }