Implement dirty bits for RendererGL's basic state.

src/libANGLE/Context.cpp

@@ -186,6 +186,9 @@ void Context::makeCurrent(egl::Surface *surface)
         mHasBeenCurrent = true;
     }
 
+    // TODO(jmadill): Rework this when we support ContextImpl
+    mState.setAllDirtyBits();
+
     // Update default framebuffer
     Framebuffer *defaultFBO = mFramebufferMap[0];
 
@@ -1237,6 +1240,7 @@ bool Context::getIndexedQueryParameterInfo(GLenum target, GLenum *type, unsigned
 
 Error Context::drawArrays(GLenum mode, GLint first, GLsizei count, GLsizei instances)
 {
+    syncRendererState();
     Error error = mRenderer->drawArrays(getData(), mode, first, count, instances);
     if (error.isError())
     {
@@ -1263,6 +1267,7 @@ Error Context::drawElements(GLenum mode, GLsizei count, GLenum type,
                             const GLvoid *indices, GLsizei instances,
                             const RangeUI &indexRange)
 {
+    syncRendererState();
     return mRenderer->drawElements(getData(), mode, count, type, indices, instances, indexRange);
 }
 
@@ -1661,4 +1666,23 @@ void Context::initCaps(GLuint clientVersion)
     }
 }
 
+void Context::syncRendererState()
+{
+    const State::DirtyBits &dirtyBits = mState.getDirtyBits();
+    if (dirtyBits.any())
+    {
+        mRenderer->syncState(mState, dirtyBits);
+        mState.clearDirtyBits();
+    }
+}
+
+void Context::syncRendererState(const State::DirtyBits &bitMask)
+{
+    const State::DirtyBits &dirtyBits = (mState.getDirtyBits() & bitMask);
+    if (dirtyBits.any())
+    {
+        mRenderer->syncState(mState, dirtyBits);
+        mState.clearDirtyBits(dirtyBits);
+    }
+}
 }

src/libANGLE/Context.h

@@ -204,6 +204,8 @@ class Context final : angle::NonCopyable
     const State &getState() const { return mState; }
 
     const Data &getData() const { return mData; }
+    void syncRendererState();
+    void syncRendererState(const State::DirtyBits &bitMask);
 
   private:
     void detachBuffer(GLuint buffer);

src/libANGLE/Framebuffer.cpp

@@ -511,29 +511,57 @@ Error Framebuffer::invalidateSub(size_t count, const GLenum *attachments, const
     return mImpl->invalidateSub(count, attachments, area);
 }
 
-Error Framebuffer::clear(const gl::Data &data, GLbitfield mask)
+Error Framebuffer::clear(Context *context, GLbitfield mask)
 {
-    return mImpl->clear(data, mask);
+    // Sync the clear state
+    context->syncRendererState(context->getState().clearStateBitMask());
+
+    return mImpl->clear(context->getData(), mask);
 }
 
-Error Framebuffer::clearBufferfv(const State &state, GLenum buffer, GLint drawbuffer, const GLfloat *values)
+Error Framebuffer::clearBufferfv(Context *context,
+                                 GLenum buffer,
+                                 GLint drawbuffer,
+                                 const GLfloat *values)
 {
-    return mImpl->clearBufferfv(state, buffer, drawbuffer, values);
+    // Sync the clear state
+    context->syncRendererState(context->getState().clearStateBitMask());
+
+    return mImpl->clearBufferfv(context->getState(), buffer, drawbuffer, values);
 }
 
-Error Framebuffer::clearBufferuiv(const State &state, GLenum buffer, GLint drawbuffer, const GLuint *values)
+Error Framebuffer::clearBufferuiv(Context *context,
+                                  GLenum buffer,
+                                  GLint drawbuffer,
+                                  const GLuint *values)
 {
-    return mImpl->clearBufferuiv(state, buffer, drawbuffer, values);
+    // Sync the clear state
+    context->syncRendererState(context->getState().clearStateBitMask());
+
+    return mImpl->clearBufferuiv(context->getState(), buffer, drawbuffer, values);
 }
 
-Error Framebuffer::clearBufferiv(const State &state, GLenum buffer, GLint drawbuffer, const GLint *values)
+Error Framebuffer::clearBufferiv(Context *context,
+                                 GLenum buffer,
+                                 GLint drawbuffer,
+                                 const GLint *values)
 {
-    return mImpl->clearBufferiv(state, buffer, drawbuffer, values);
+    // Sync the clear state
+    context->syncRendererState(context->getState().clearStateBitMask());
+
+    return mImpl->clearBufferiv(context->getState(), buffer, drawbuffer, values);
 }
 
-Error Framebuffer::clearBufferfi(const State &state, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+Error Framebuffer::clearBufferfi(Context *context,
+                                 GLenum buffer,
+                                 GLint drawbuffer,
+                                 GLfloat depth,
+                                 GLint stencil)
 {
-    return mImpl->clearBufferfi(state, buffer, drawbuffer, depth, stencil);
+    // Sync the clear state
+    context->syncRendererState(context->getState().clearStateBitMask());
+
+    return mImpl->clearBufferfi(context->getState(), buffer, drawbuffer, depth, stencil);
 }
 
 GLenum Framebuffer::getImplementationColorReadFormat() const
@@ -546,8 +574,17 @@ GLenum Framebuffer::getImplementationColorReadType() const
     return mImpl->getImplementationColorReadType();
 }
 
-Error Framebuffer::readPixels(const gl::State &state, const gl::Rectangle &area, GLenum format, GLenum type, GLvoid *pixels) const
+Error Framebuffer::readPixels(Context *context,
+                              const gl::Rectangle &area,
+                              GLenum format,
+                              GLenum type,
+                              GLvoid *pixels) const
 {
+    const State &state = context->getState();
+
+    // Sync pack state
+    context->syncRendererState(state.packStateBitMask());
+
     Error error = mImpl->readPixels(state, area, format, type, pixels);
     if (error.isError())
     {

src/libANGLE/Framebuffer.h

@@ -32,6 +32,7 @@ class Surface;
 
 namespace gl
 {
+class Context;
 class Renderbuffer;
 class State;
 class Texture;
@@ -121,15 +122,23 @@ class Framebuffer
     Error invalidate(size_t count, const GLenum *attachments);
     Error invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area);
 
-    Error clear(const gl::Data &data, GLbitfield mask);
-    Error clearBufferfv(const State &state, GLenum buffer, GLint drawbuffer, const GLfloat *values);
-    Error clearBufferuiv(const State &state, GLenum buffer, GLint drawbuffer, const GLuint *values);
-    Error clearBufferiv(const State &state, GLenum buffer, GLint drawbuffer, const GLint *values);
-    Error clearBufferfi(const State &state, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+    Error clear(Context *context, GLbitfield mask);
+    Error clearBufferfv(Context *context, GLenum buffer, GLint drawbuffer, const GLfloat *values);
+    Error clearBufferuiv(Context *context, GLenum buffer, GLint drawbuffer, const GLuint *values);
+    Error clearBufferiv(Context *context, GLenum buffer, GLint drawbuffer, const GLint *values);
+    Error clearBufferfi(Context *context,
+                        GLenum buffer,
+                        GLint drawbuffer,
+                        GLfloat depth,
+                        GLint stencil);
 
     GLenum getImplementationColorReadFormat() const;
     GLenum getImplementationColorReadType() const;
-    Error readPixels(const gl::State &state, const gl::Rectangle &area, GLenum format, GLenum type, GLvoid *pixels) const;
+    Error readPixels(Context *context,
+                     const gl::Rectangle &area,
+                     GLenum format,
+                     GLenum type,
+                     GLvoid *pixels) const;
 
     Error blit(const gl::State &state, const gl::Rectangle &sourceArea, const gl::Rectangle &destArea,
                GLbitfield mask, GLenum filter, const gl::Framebuffer *sourceFramebuffer);

src/libANGLE/Image_unittest.cpp

@@ -90,8 +90,8 @@ TEST(ImageTest, RespecificationReleasesReferences)
     EXPECT_CALL(*textureImpl, setImage(_, _, _, _, _, _, _, _))
         .WillOnce(Return(gl::Error(GL_NO_ERROR)))
         .RetiresOnSaturation();
-    texture->setImage(GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1), GL_RGBA, GL_UNSIGNED_BYTE,
-                      gl::PixelUnpackState(), nullptr);
+    texture->setImage(nullptr, GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1), GL_RGBA,
+                      GL_UNSIGNED_BYTE, nullptr);
 
     rx::MockImageImpl *imageImpl = new rx::MockImageImpl();
     egl::Image *image = new egl::Image(imageImpl, EGL_GL_TEXTURE_2D, texture, egl::AttributeMap());
@@ -110,8 +110,8 @@ TEST(ImageTest, RespecificationReleasesReferences)
         .WillOnce(Return(gl::Error(GL_NO_ERROR)))
         .RetiresOnSaturation();
 
-    texture->setImage(GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1), GL_RGBA, GL_UNSIGNED_BYTE,
-                      gl::PixelUnpackState(), nullptr);
+    texture->setImage(nullptr, GL_TEXTURE_2D, 0, GL_RGBA8, gl::Extents(1, 1, 1), GL_RGBA,
+                      GL_UNSIGNED_BYTE, nullptr);
 
     EXPECT_EQ(texture->getRefCount(), 1u);
     EXPECT_EQ(image->getRefCount(), 1u);

src/libANGLE/State.h

@@ -9,15 +9,17 @@
 #ifndef LIBANGLE_STATE_H_
 #define LIBANGLE_STATE_H_
 
+#include <bitset>
+
 #include "common/angleutils.h"
+#include "libANGLE/Program.h"
 #include "libANGLE/RefCountObject.h"
-#include "libANGLE/angletypes.h"
-#include "libANGLE/VertexAttribute.h"
 #include "libANGLE/Renderbuffer.h"
+#include "libANGLE/Sampler.h"
 #include "libANGLE/Texture.h"
 #include "libANGLE/TransformFeedback.h"
-#include "libANGLE/Program.h"
-#include "libANGLE/Sampler.h"
+#include "libANGLE/VertexAttribute.h"
+#include "libANGLE/angletypes.h"
 
 namespace gl
 {
@@ -252,6 +254,73 @@ class State : angle::NonCopyable
 
     bool hasMappedBuffer(GLenum target) const;
 
+    enum DirtyBitType
+    {
+        DIRTY_BIT_SCISSOR_TEST_ENABLED,
+        DIRTY_BIT_SCISSOR,
+        DIRTY_BIT_VIEWPORT,
+        DIRTY_BIT_DEPTH_RANGE,
+        DIRTY_BIT_BLEND_ENABLED,
+        DIRTY_BIT_BLEND_COLOR,
+        DIRTY_BIT_BLEND_FUNCS,
+        DIRTY_BIT_BLEND_EQUATIONS,
+        DIRTY_BIT_COLOR_MASK,
+        DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED,
+        DIRTY_BIT_SAMPLE_COVERAGE_ENABLED,
+        DIRTY_BIT_SAMPLE_COVERAGE,
+        DIRTY_BIT_DEPTH_TEST_ENABLED,
+        DIRTY_BIT_DEPTH_FUNC,
+        DIRTY_BIT_DEPTH_MASK,
+        DIRTY_BIT_STENCIL_TEST_ENABLED,
+        DIRTY_BIT_STENCIL_FUNCS_FRONT,
+        DIRTY_BIT_STENCIL_FUNCS_BACK,
+        DIRTY_BIT_STENCIL_OPS_FRONT,
+        DIRTY_BIT_STENCIL_OPS_BACK,
+        DIRTY_BIT_STENCIL_WRITEMASK_FRONT,
+        DIRTY_BIT_STENCIL_WRITEMASK_BACK,
+        DIRTY_BIT_CULL_FACE_ENABLED,
+        DIRTY_BIT_CULL_FACE,
+        DIRTY_BIT_FRONT_FACE,
+        DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED,
+        DIRTY_BIT_POLYGON_OFFSET,
+        DIRTY_BIT_MULTISAMPLE_ENABLED,
+        DIRTY_BIT_RASTERIZER_DISCARD_ENABLED,
+        DIRTY_BIT_LINE_WIDTH,
+        DIRTY_BIT_PRIMITIVE_RESTART_ENABLED,
+        DIRTY_BIT_CLEAR_COLOR,
+        DIRTY_BIT_CLEAR_DEPTH,
+        DIRTY_BIT_CLEAR_STENCIL,
+        DIRTY_BIT_UNPACK_ALIGNMENT,
+        DIRTY_BIT_UNPACK_ROW_LENGTH,
+        DIRTY_BIT_PACK_ALIGNMENT,
+        DIRTY_BIT_PACK_REVERSE_ROW_ORDER,
+        DIRTY_BIT_DITHER_ENABLED,
+        DIRTY_BIT_GENERATE_MIPMAP_HINT,
+        DIRTY_BIT_SHADER_DERIVATIVE_HINT,
+        DIRTY_BIT_READ_FRAMEBUFFER_BINDING,
+        DIRTY_BIT_READ_FRAMEBUFFER_OBJECT,
+        DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING,
+        DIRTY_BIT_DRAW_FRAMEBUFFER_OBJECT,
+        DIRTY_BIT_RENDERBUFFER_BINDING,
+        DIRTY_BIT_VERTEX_ARRAY_BINDING,
+        DIRTY_BIT_VERTEX_ARRAY_OBJECT,
+        DIRTY_BIT_PROGRAM_BINDING,
+        DIRTY_BIT_PROGRAM_OBJECT,
+        DIRTY_BIT_INVALID,
+        DIRTY_BIT_MAX = DIRTY_BIT_INVALID,
+    };
+
+    typedef std::bitset<DIRTY_BIT_MAX> DirtyBits;
+    const DirtyBits &getDirtyBits() const { return mDirtyBits; }
+    void clearDirtyBits() { mDirtyBits.reset(); }
+    void clearDirtyBits(const DirtyBits &bitset) { mDirtyBits &= ~bitset; }
+    void setAllDirtyBits() { mDirtyBits.set(); }
+
+    // Dirty bit masks
+    const DirtyBits &unpackStateBitMask() const { return mUnpackStateBitMask; }
+    const DirtyBits &packStateBitMask() const { return mPackStateBitMask; }
+    const DirtyBits &clearStateBitMask() const { return mClearStateBitMask; }
+
   private:
     // Cached values from Context's caps
     GLuint mMaxDrawBuffers;
@@ -320,6 +389,11 @@ class State : angle::NonCopyable
     PixelPackState mPack;
 
     bool mPrimitiveRestart;
+
+    DirtyBits mDirtyBits;
+    DirtyBits mUnpackStateBitMask;
+    DirtyBits mPackStateBitMask;
+    DirtyBits mClearStateBitMask;
 };
 
 }

src/libANGLE/Texture.cpp

@@ -11,6 +11,7 @@
 #include "common/mathutil.h"
 #include "common/utilities.h"
 #include "libANGLE/Config.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/Data.h"
 #include "libANGLE/Image.h"
 #include "libANGLE/Surface.h"
@@ -189,8 +190,14 @@ egl::Surface *Texture::getBoundSurface() const
     return mBoundSurface;
 }
 
-Error Texture::setImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size, GLenum format, GLenum type,
-                        const PixelUnpackState &unpack, const uint8_t *pixels)
+Error Texture::setImage(Context *context,
+                        GLenum target,
+                        size_t level,
+                        GLenum internalFormat,
+                        const Extents &size,
+                        GLenum format,
+                        GLenum type,
+                        const uint8_t *pixels)
 {
     ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target)));
 
@@ -198,6 +205,15 @@ Error Texture::setImage(GLenum target, size_t level, GLenum internalFormat, cons
     releaseTexImageInternal();
     orphanImages();
 
+    // Hack: allow nullptr for testing
+    if (context != nullptr)
+    {
+        // Sync the unpack state
+        context->syncRendererState(context->getState().unpackStateBitMask());
+    }
+
+    const PixelUnpackState &unpack =
+        context ? context->getState().getUnpackState() : PixelUnpackState();
     Error error = mTexture->setImage(target, level, internalFormat, size, format, type, unpack, pixels);
     if (error.isError())
     {
@@ -209,16 +225,30 @@ Error Texture::setImage(GLenum target, size_t level, GLenum internalFormat, cons
     return Error(GL_NO_ERROR);
 }
 
-Error Texture::setSubImage(GLenum target, size_t level, const Box &area, GLenum format, GLenum type,
-                           const PixelUnpackState &unpack, const uint8_t *pixels)
+Error Texture::setSubImage(Context *context,
+                           GLenum target,
+                           size_t level,
+                           const Box &area,
+                           GLenum format,
+                           GLenum type,
+                           const uint8_t *pixels)
 {
     ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target)));
 
+    // Sync the unpack state
+    context->syncRendererState(context->getState().unpackStateBitMask());
+
+    const PixelUnpackState &unpack = context->getState().getUnpackState();
     return mTexture->setSubImage(target, level, area, format, type, unpack, pixels);
 }
 
-Error Texture::setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size,
-                                  const PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels)
+Error Texture::setCompressedImage(Context *context,
+                                  GLenum target,
+                                  size_t level,
+                                  GLenum internalFormat,
+                                  const Extents &size,
+                                  size_t imageSize,
+                                  const uint8_t *pixels)
 {
     ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target)));
 
@@ -226,6 +256,10 @@ Error Texture::setCompressedImage(GLenum target, size_t level, GLenum internalFo
     releaseTexImageInternal();
     orphanImages();
 
+    // Sync the unpack state
+    context->syncRendererState(context->getState().unpackStateBitMask());
+
+    const PixelUnpackState &unpack = context->getState().getUnpackState();
     Error error = mTexture->setCompressedImage(target, level, internalFormat, size, unpack, imageSize, pixels);
     if (error.isError())
     {
@@ -237,11 +271,20 @@ Error Texture::setCompressedImage(GLenum target, size_t level, GLenum internalFo
     return Error(GL_NO_ERROR);
 }
 
-Error Texture::setCompressedSubImage(GLenum target, size_t level, const Box &area, GLenum format,
-                                     const PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels)
+Error Texture::setCompressedSubImage(Context *context,
+                                     GLenum target,
+                                     size_t level,
+                                     const Box &area,
+                                     GLenum format,
+                                     size_t imageSize,
+                                     const uint8_t *pixels)
 {
     ASSERT(target == mTarget || (mTarget == GL_TEXTURE_CUBE_MAP && IsCubeMapTextureTarget(target)));
 
+    // Sync the unpack state
+    context->syncRendererState(context->getState().unpackStateBitMask());
+
+    const PixelUnpackState &unpack = context->getState().getUnpackState();
     return mTexture->setCompressedSubImage(target, level, area, format, unpack, imageSize, pixels);
 }
 

src/libANGLE/Texture.h

@@ -29,6 +29,7 @@ class Surface;
 
 namespace gl
 {
+class Context;
 class Framebuffer;
 struct Data;
 
@@ -38,8 +39,7 @@ class Texture final : public egl::ImageSibling
 {
   public:
     Texture(rx::TextureImpl *impl, GLuint id, GLenum target);
-
-    virtual ~Texture();
+    ~Texture();
 
     GLenum getTarget() const;
 
@@ -59,26 +59,53 @@ class Texture final : public egl::ImageSibling
     bool isCubeComplete() const;
     size_t getMipCompleteLevels() const;
 
-    virtual Error setImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size, GLenum format, GLenum type,
-                           const PixelUnpackState &unpack, const uint8_t *pixels);
-    virtual Error setSubImage(GLenum target, size_t level, const Box &area, GLenum format, GLenum type,
-                              const PixelUnpackState &unpack, const uint8_t *pixels);
-
-    virtual Error setCompressedImage(GLenum target, size_t level, GLenum internalFormat, const Extents &size,
-                                     const PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels);
-    virtual Error setCompressedSubImage(GLenum target, size_t level, const Box &area, GLenum format,
-                                        const PixelUnpackState &unpack, size_t imageSize, const uint8_t *pixels);
-
-    virtual Error copyImage(GLenum target, size_t level, const Rectangle &sourceArea, GLenum internalFormat,
-                            const Framebuffer *source);
-    virtual Error copySubImage(GLenum target, size_t level, const Offset &destOffset, const Rectangle &sourceArea,
-                              const Framebuffer *source);
-
-    virtual Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const Extents &size);
+    Error setImage(Context *context,
+                   GLenum target,
+                   size_t level,
+                   GLenum internalFormat,
+                   const Extents &size,
+                   GLenum format,
+                   GLenum type,
+                   const uint8_t *pixels);
+    Error setSubImage(Context *context,
+                      GLenum target,
+                      size_t level,
+                      const Box &area,
+                      GLenum format,
+                      GLenum type,
+                      const uint8_t *pixels);
+
+    Error setCompressedImage(Context *context,
+                             GLenum target,
+                             size_t level,
+                             GLenum internalFormat,
+                             const Extents &size,
+                             size_t imageSize,
+                             const uint8_t *pixels);
+    Error setCompressedSubImage(Context *context,
+                                GLenum target,
+                                size_t level,
+                                const Box &area,
+                                GLenum format,
+                                size_t imageSize,
+                                const uint8_t *pixels);
+
+    Error copyImage(GLenum target,
+                    size_t level,
+                    const Rectangle &sourceArea,
+                    GLenum internalFormat,
+                    const Framebuffer *source);
+    Error copySubImage(GLenum target,
+                       size_t level,
+                       const Offset &destOffset,
+                       const Rectangle &sourceArea,
+                       const Framebuffer *source);
+
+    Error setStorage(GLenum target, size_t levels, GLenum internalFormat, const Extents &size);
 
     Error setEGLImageTarget(GLenum target, egl::Image *imageTarget);
 
-    virtual Error generateMipmaps();
+    Error generateMipmaps();
 
     bool isImmutable() const;
     GLsizei immutableLevelCount();

src/libANGLE/renderer/Renderer.h

@@ -13,6 +13,7 @@
 #include "libANGLE/Caps.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/Framebuffer.h"
+#include "libANGLE/State.h"
 #include "libANGLE/Uniform.h"
 #include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/ImplFactory.h"
@@ -29,12 +30,6 @@ class Display;
 class Surface;
 }
 
-namespace gl
-{
-class Buffer;
-struct Data;
-}
-
 namespace rx
 {
 struct TranslatedIndexData;
@@ -72,6 +67,8 @@ class Renderer : public ImplFactory
     virtual void pushGroupMarker(GLsizei length, const char *marker) = 0;
     virtual void popGroupMarker() = 0;
 
+    virtual void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) = 0;
+
     // Renderer capabilities
     const gl::Caps &getRendererCaps() const;
     const gl::TextureCapsMap &getRendererTextureCaps() const;

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -545,20 +545,26 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLenum type)
     {
         const GLubyte color[] = { 0, 0, 0, 255 };
         const gl::Extents colorSize(1, 1, 1);
-        const gl::PixelUnpackState incompleteUnpackState(1, 0);
+        const gl::PixelUnpackState unpack(1, 0);
+        const gl::Box area(0, 0, 0, 1, 1, 1);
 
-        gl::Texture* t = new gl::Texture(createTexture(type), std::numeric_limits<GLuint>::max(), type);
+        // Skip the API layer to avoid needing to pass the Context and mess with dirty bits.
+        gl::Texture *t =
+            new gl::Texture(createTexture(type), std::numeric_limits<GLuint>::max(), type);
+        t->setStorage(type, 1, GL_RGBA8, colorSize);
 
         if (type == GL_TEXTURE_CUBE_MAP)
         {
             for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; face++)
             {
-                t->setImage(face, 0, GL_RGBA, colorSize, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
+                t->getImplementation()->setSubImage(face, 0, area, GL_RGBA8, GL_UNSIGNED_BYTE,
+                                                    unpack, color);
             }
         }
         else
         {
-            t->setImage(type, 0, GL_RGBA, colorSize, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color);
+            t->getImplementation()->setSubImage(type, 0, area, GL_RGBA8, GL_UNSIGNED_BYTE, unpack,
+                                                color);
         }
 
         mIncompleteTextures[type].set(t);

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -194,6 +194,11 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
                                               GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea) = 0;
 
+    void syncState(const gl::State & /*state*/, const gl::State::DirtyBits &bitmask) override
+    {
+        // TODO(jmadill): implement state sync for D3D renderers;
+    }
+
     // Device lost
     void notifyDeviceLost() override;
     virtual bool resetDevice() = 0;

src/libANGLE/renderer/gl/FramebufferGL.cpp

@@ -185,28 +185,14 @@ gl::Error FramebufferGL::invalidateSub(size_t count, const GLenum *attachments,
 
 gl::Error FramebufferGL::clear(const gl::Data &data, GLbitfield mask)
 {
-    mStateManager->setClearState(*data.state, mask);
     mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
     mFunctions->clear(mask);
 
     return gl::Error(GL_NO_ERROR);
 }
 
-static GLbitfield GetClearBufferMask(GLenum buffer)
-{
-    switch (buffer)
-    {
-      case GL_COLOR:          return GL_COLOR_BUFFER_BIT;
-      case GL_DEPTH:          return GL_DEPTH_BUFFER_BIT;
-      case GL_STENCIL:        return GL_STENCIL_BUFFER_BIT;
-      case GL_DEPTH_STENCIL:  return GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
-      default: UNREACHABLE(); return 0;
-    }
-}
-
 gl::Error FramebufferGL::clearBufferfv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLfloat *values)
 {
-    mStateManager->setClearState(state, GetClearBufferMask(buffer));
     mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
     mFunctions->clearBufferfv(buffer, drawbuffer, values);
 
@@ -215,7 +201,6 @@ gl::Error FramebufferGL::clearBufferfv(const gl::State &state, GLenum buffer, GL
 
 gl::Error FramebufferGL::clearBufferuiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLuint *values)
 {
-    mStateManager->setClearState(state, GetClearBufferMask(buffer));
     mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
     mFunctions->clearBufferuiv(buffer, drawbuffer, values);
 
@@ -224,7 +209,6 @@ gl::Error FramebufferGL::clearBufferuiv(const gl::State &state, GLenum buffer, G
 
 gl::Error FramebufferGL::clearBufferiv(const gl::State &state, GLenum buffer, GLint drawbuffer, const GLint *values)
 {
-    mStateManager->setClearState(state, GetClearBufferMask(buffer));
     mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
     mFunctions->clearBufferiv(buffer, drawbuffer, values);
 
@@ -233,7 +217,6 @@ gl::Error FramebufferGL::clearBufferiv(const gl::State &state, GLenum buffer, GL
 
 gl::Error FramebufferGL::clearBufferfi(const gl::State &state, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    mStateManager->setClearState(state, GetClearBufferMask(buffer));
     mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
     mFunctions->clearBufferfi(buffer, drawbuffer, depth, stencil);
 
@@ -263,7 +246,6 @@ gl::Error FramebufferGL::readPixels(const gl::State &state, const gl::Rectangle
     {
         UNIMPLEMENTED();
     }
-    mStateManager->setPixelPackState(packState.alignment, packState.rowLength, packState.skipRows, packState.skipPixels);
 
     mStateManager->bindFramebuffer(GL_READ_FRAMEBUFFER, mFramebufferID);
     mFunctions->readPixels(area.x, area.y, area.width, area.height, format, type, pixels);

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -324,4 +324,8 @@ void RendererGL::generateCaps(gl::Caps *outCaps, gl::TextureCapsMap* outTextureC
     nativegl_gl::GenerateCaps(mFunctions, outCaps, outTextureCaps, outExtensions, &mMaxSupportedESVersion);
 }
 
+void RendererGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
+{
+    mStateManager->syncState(state, dirtyBits);
+}
 }

src/libANGLE/renderer/gl/RendererGL.h

@@ -77,6 +77,8 @@ class RendererGL : public Renderer
     std::string getVendorString() const override;
     std::string getRendererDescription() const override;
 
+    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) override;
+
     const gl::Version &getMaxSupportedESVersion() const;
 
   private:

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -11,6 +11,7 @@
 
 #include "common/debug.h"
 #include "libANGLE/Error.h"
+#include "libANGLE/State.h"
 #include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/gl/functionsgl_typedefs.h"
 
@@ -28,7 +29,7 @@ namespace rx
 
 class FunctionsGL;
 
-class StateManagerGL : angle::NonCopyable
+class StateManagerGL final : angle::NonCopyable
 {
   public:
     StateManagerGL(const FunctionsGL *functions, const gl::Caps &rendererCaps);
@@ -45,18 +46,15 @@ class StateManagerGL : angle::NonCopyable
     void bindBuffer(GLenum type, GLuint buffer);
     void activeTexture(size_t unit);
     void bindTexture(GLenum type, GLuint texture);
-    void setPixelUnpackState(GLint alignment, GLint rowLength, GLint skipRows, GLint skipPixels,
-                             GLint imageHeight, GLint skipImages);
-    void setPixelPackState(GLint alignment, GLint rowLength, GLint skipRows, GLint skipPixels);
     void bindFramebuffer(GLenum type, GLuint framebuffer);
     void bindRenderbuffer(GLenum type, GLuint renderbuffer);
 
-    void setClearState(const gl::State &state, GLbitfield mask);
-
     gl::Error setDrawArraysState(const gl::Data &data, GLint first, GLsizei count);
     gl::Error setDrawElementsState(const gl::Data &data, GLsizei count, GLenum type, const GLvoid *indices,
                                    const GLvoid **outIndices);
 
+    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
+
   private:
     gl::Error setGenericDrawState(const gl::Data &data);
 
@@ -103,6 +101,16 @@ class StateManagerGL : angle::NonCopyable
     void setClearDepth(float clearDepth);
     void setClearStencil(GLint clearStencil);
 
+    void setPixelUnpackState(const gl::PixelUnpackState &unpack);
+    void setPixelUnpackState(GLint alignment,
+                             GLint rowLength,
+                             GLint skipRows,
+                             GLint skipPixels,
+                             GLint imageHeight,
+                             GLint skipImages);
+    void setPixelPackState(const gl::PixelPackState &pack);
+    void setPixelPackState(GLint alignment, GLint rowLength, GLint skipRows, GLint skipPixels);
+
     const FunctionsGL *mFunctions;
 
     GLuint mProgram;

src/libANGLE/renderer/gl/TextureGL.cpp

@@ -23,17 +23,6 @@
 namespace rx
 {
 
-static void SetUnpackStateForTexImage(StateManagerGL *stateManager, const gl::PixelUnpackState &unpack)
-{
-    const gl::Buffer *unpackBuffer = unpack.pixelBuffer.get();
-    if (unpackBuffer != nullptr)
-    {
-        UNIMPLEMENTED();
-    }
-    stateManager->setPixelUnpackState(unpack.alignment, unpack.rowLength, unpack.skipRows,
-                                      unpack.skipPixels, unpack.imageHeight, unpack.skipImages);
-}
-
 static bool UseTexImage2D(GLenum textureType)
 {
     return textureType == GL_TEXTURE_2D || textureType == GL_TEXTURE_CUBE_MAP;
@@ -93,8 +82,6 @@ gl::Error TextureGL::setImage(GLenum target, size_t level, GLenum internalFormat
     UNUSED_ASSERTION_VARIABLE(&CompatibleTextureTarget); // Reference this function to avoid warnings.
     ASSERT(CompatibleTextureTarget(mTextureType, target));
 
-    SetUnpackStateForTexImage(mStateManager, unpack);
-
     nativegl::TexImageFormat texImageFormat =
         nativegl::GetTexImageFormat(mFunctions, mWorkarounds, internalFormat, format, type);
 
@@ -124,8 +111,6 @@ gl::Error TextureGL::setSubImage(GLenum target, size_t level, const gl::Box &are
 {
     ASSERT(CompatibleTextureTarget(mTextureType, target));
 
-    SetUnpackStateForTexImage(mStateManager, unpack);
-
     nativegl::TexSubImageFormat texSubImageFormat =
         nativegl::GetTexSubImageFormat(mFunctions, mWorkarounds, format, type);
 
@@ -155,8 +140,6 @@ gl::Error TextureGL::setCompressedImage(GLenum target, size_t level, GLenum inte
 {
     ASSERT(CompatibleTextureTarget(mTextureType, target));
 
-    SetUnpackStateForTexImage(mStateManager, unpack);
-
     nativegl::CompressedTexImageFormat compressedTexImageFormat =
         nativegl::GetCompressedTexImageFormat(mFunctions, mWorkarounds, internalFormat);
 
@@ -185,8 +168,6 @@ gl::Error TextureGL::setCompressedSubImage(GLenum target, size_t level, const gl
 {
     ASSERT(CompatibleTextureTarget(mTextureType, target));
 
-    SetUnpackStateForTexImage(mStateManager, unpack);
-
     nativegl::CompressedTexSubImageFormat compressedTexSubImageFormat =
         nativegl::GetCompressedSubTexImageFormat(mFunctions, mWorkarounds, format);
 

src/libGLESv2/entry_points_gles_2_0.cpp

@@ -628,7 +628,7 @@ void GL_APIENTRY Clear(GLbitfield mask)
             return;
         }
 
-        Error error = framebufferObject->clear(context->getData(), mask);
+        Error error = framebufferObject->clear(context, mask);
         if (error.isError())
         {
             context->recordError(error);
@@ -743,8 +743,9 @@ void GL_APIENTRY CompressedTexImage2D(GLenum target, GLint level, GLenum interna
 
         Extents size(width, height, 1);
         Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-        Error error = texture->setCompressedImage(target, level, internalformat, size, context->getState().getUnpackState(), 
-                                                  imageSize, reinterpret_cast<const uint8_t *>(data));
+        Error error =
+            texture->setCompressedImage(context, target, level, internalformat, size, imageSize,
+                                        reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
         {
             context->recordError(error);
@@ -785,11 +786,11 @@ void GL_APIENTRY CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffs
             return;
         }
 
-
         Box area(xoffset, yoffset, 0, width, height, 1);
         Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-        Error error = texture->setCompressedSubImage(target, level, area, format, context->getState().getUnpackState(),
-                                                     imageSize, reinterpret_cast<const uint8_t *>(data));
+        Error error =
+            texture->setCompressedSubImage(context, target, level, area, format, imageSize,
+                                           reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
         {
             context->recordError(error);
@@ -3319,7 +3320,7 @@ void GL_APIENTRY ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
         ASSERT(framebufferObject);
 
         Rectangle area(x, y, width, height);
-        Error error = framebufferObject->readPixels(context->getState(), area, format, type, pixels);
+        Error error = framebufferObject->readPixels(context, area, format, type, pixels);
         if (error.isError())
         {
             context->recordError(error);
@@ -3657,7 +3658,7 @@ void GL_APIENTRY TexImage2D(GLenum target, GLint level, GLint internalformat, GL
 
         Extents size(width, height, 1);
         Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-        Error error = texture->setImage(target, level, internalformat, size, format, type, context->getState().getUnpackState(),
+        Error error = texture->setImage(context, target, level, internalformat, size, format, type,
                                         reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())
         {
@@ -3810,7 +3811,7 @@ void GL_APIENTRY TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint
 
         Box area(xoffset, yoffset, 0, width, height, 1);
         Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
-        Error error = texture->setSubImage(target, level, area, format, type, context->getState().getUnpackState(),
+        Error error = texture->setSubImage(context, target, level, area, format, type,
                                            reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())
         {

src/libGLESv2/entry_points_gles_2_0_ext.cpp

@@ -496,7 +496,7 @@ void GL_APIENTRY ReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
         ASSERT(framebufferObject);
 
         Rectangle area(x, y, width, height);
-        Error error = framebufferObject->readPixels(context->getState(), area, format, type, data);
+        Error error = framebufferObject->readPixels(context, area, format, type, data);
         if (error.isError())
         {
             context->recordError(error);

src/libGLESv2/entry_points_gles_3_0.cpp

@@ -109,7 +109,7 @@ void GL_APIENTRY TexImage3D(GLenum target, GLint level, GLint internalformat, GL
 
         Extents size(width, height, depth);
         Texture *texture = context->getTargetTexture(target);
-        Error error = texture->setImage(target, level, internalformat, size, format, type, context->getState().getUnpackState(),
+        Error error = texture->setImage(context, target, level, internalformat, size, format, type,
                                         reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())
         {
@@ -151,7 +151,7 @@ void GL_APIENTRY TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint
 
         Box area(xoffset, yoffset, zoffset, width, height, depth);
         Texture *texture = context->getTargetTexture(target);
-        Error error = texture->setSubImage(target, level, area, format, type, context->getState().getUnpackState(),
+        Error error = texture->setSubImage(context, target, level, area, format, type,
                                            reinterpret_cast<const uint8_t *>(pixels));
         if (error.isError())
         {
@@ -214,8 +214,9 @@ void GL_APIENTRY CompressedTexImage3D(GLenum target, GLint level, GLenum interna
 
         Extents size(width, height, depth);
         Texture *texture = context->getTargetTexture(target);
-        Error error = texture->setCompressedImage(target, level, internalformat, size, context->getState().getUnpackState(),
-                                                  imageSize, reinterpret_cast<const uint8_t *>(data));
+        Error error =
+            texture->setCompressedImage(context, target, level, internalformat, size, imageSize,
+                                        reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
         {
             context->recordError(error);
@@ -268,8 +269,9 @@ void GL_APIENTRY CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffs
 
         Box area(xoffset, yoffset, zoffset, width, height, depth);
         Texture *texture = context->getTargetTexture(target);
-        Error error = texture->setCompressedSubImage(target, level, area, format, context->getState().getUnpackState(),
-                                                     imageSize, reinterpret_cast<const uint8_t *>(data));
+        Error error =
+            texture->setCompressedSubImage(context, target, level, area, format, imageSize,
+                                           reinterpret_cast<const uint8_t *>(data));
         if (error.isError())
         {
             context->recordError(error);
@@ -1731,7 +1733,7 @@ void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* val
         Framebuffer *framebufferObject = context->getState().getDrawFramebuffer();
         ASSERT(framebufferObject);
 
-        Error error = framebufferObject->clearBufferiv(context->getState(), buffer, drawbuffer, value);
+        Error error = framebufferObject->clearBufferiv(context, buffer, drawbuffer, value);
         if (error.isError())
         {
             context->recordError(error);
@@ -1771,7 +1773,7 @@ void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* v
         Framebuffer *framebufferObject = context->getState().getDrawFramebuffer();
         ASSERT(framebufferObject);
 
-        Error error = framebufferObject->clearBufferuiv(context->getState(), buffer, drawbuffer, value);
+        Error error = framebufferObject->clearBufferuiv(context, buffer, drawbuffer, value);
         if (error.isError())
         {
             context->recordError(error);
@@ -1819,7 +1821,7 @@ void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* v
         Framebuffer *framebufferObject = context->getState().getDrawFramebuffer();
         ASSERT(framebufferObject);
 
-        Error error = framebufferObject->clearBufferfv(context->getState(), buffer, drawbuffer, value);
+        Error error = framebufferObject->clearBufferfv(context, buffer, drawbuffer, value);
         if (error.isError())
         {
             context->recordError(error);
@@ -1865,7 +1867,7 @@ void GL_APIENTRY ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, G
             return;
         }
 
-        Error error = framebufferObject->clearBufferfi(context->getState(), buffer, drawbuffer, depth, stencil);
+        Error error = framebufferObject->clearBufferfi(context, buffer, drawbuffer, depth, stencil);
         if (error.isError())
         {
             context->recordError(error);