Move incomplete texture logic to shared helper.

src/common/angleutils.cpp

@@ -14,6 +14,8 @@
 
 namespace angle
 {
+// dirtyPointer is a special value that will make the comparison with any valid pointer fail and
+// force the renderer to re-apply the state.
 const uintptr_t DirtyPointer = std::numeric_limits<uintptr_t>::max();
 }
 

src/libANGLE/Framebuffer.cpp

@@ -1648,7 +1648,7 @@ void Framebuffer::setAttachmentImpl(const Context *context,
                              &mDirtyStencilAttachmentBinding, type, binding, textureIndex,
                              attachmentObj, numViews, baseViewIndex, multiviewLayout,
                              viewportOffsets);
-            return;
+            break;
         }
 
         case GL_DEPTH:
@@ -1690,6 +1690,8 @@ void Framebuffer::setAttachmentImpl(const Context *context,
         }
         break;
     }
+
+    mAttachedTextures.reset();
 }
 
 void Framebuffer::updateAttachment(const Context *context,
@@ -2144,4 +2146,35 @@ bool Framebuffer::partialBufferClearNeedsInit(const Context *context, GLenum buf
     }
 }
 
+bool Framebuffer::hasTextureAttachment(const Texture *texture) const
+{
+    if (!mAttachedTextures.valid())
+    {
+        std::set<const FramebufferAttachmentObject *> attachedTextures;
+
+        for (const auto &colorAttachment : mState.mColorAttachments)
+        {
+            if (colorAttachment.isAttached() && colorAttachment.type() == GL_TEXTURE)
+            {
+                attachedTextures.insert(colorAttachment.getResource());
+            }
+        }
+
+        if (mState.mDepthAttachment.isAttached() && mState.mDepthAttachment.type() == GL_TEXTURE)
+        {
+            attachedTextures.insert(mState.mDepthAttachment.getResource());
+        }
+
+        if (mState.mStencilAttachment.isAttached() &&
+            mState.mStencilAttachment.type() == GL_TEXTURE)
+        {
+            attachedTextures.insert(mState.mStencilAttachment.getResource());
+        }
+
+        mAttachedTextures = std::move(attachedTextures);
+    }
+
+    return (mAttachedTextures.value().count(texture) > 0);
+}
+
 }  // namespace gl

src/libANGLE/Framebuffer.h

@@ -312,6 +312,8 @@ class Framebuffer final : public LabeledObject, public OnAttachmentDirtyReceiver
     Error ensureReadAttachmentInitialized(const Context *context, GLbitfield blitMask);
     Box getDimensions() const;
 
+    bool hasTextureAttachment(const Texture *texture) const;
+
   private:
     bool detachResourceById(const Context *context, GLenum resourceType, GLuint resourceId);
     bool detachMatchingAttachment(const Context *context,
@@ -377,6 +379,9 @@ class Framebuffer final : public LabeledObject, public OnAttachmentDirtyReceiver
     OnAttachmentDirtyBinding mDirtyStencilAttachmentBinding;
 
     DirtyBits mDirtyBits;
+
+    // A cache of attached textures for quick validation of feedback loops.
+    mutable Optional<std::set<const FramebufferAttachmentObject *>> mAttachedTextures;
 };
 
 }  // namespace gl

src/libANGLE/State.cpp

@@ -2274,11 +2274,12 @@ void State::syncProgramTextures(const Context *context)
             ASSERT(static_cast<size_t>(textureUnitIndex) < mCompleteTextureCache.size());
             ASSERT(static_cast<size_t>(textureUnitIndex) < newActiveTextures.size());
 
-            if (texture != nullptr)
-            {
+            ASSERT(texture);
+
             // 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))
+            if (texture->isSamplerComplete(context, sampler) &&
+                !mDrawFramebuffer->hasTextureAttachment(texture))
             {
                 texture->syncState();
                 mCompleteTextureCache[textureUnitIndex] = texture;
@@ -2292,7 +2293,6 @@ void State::syncProgramTextures(const Context *context)
             mCompleteTextureBindings[textureUnitIndex].bind(texture->getDirtyChannel());
             newActiveTextures.set(textureUnitIndex);
             mCompleteTexturesMask.set(textureUnitIndex);
-            }
 
             if (sampler != nullptr)
             {

src/libANGLE/State.h

@@ -34,8 +34,6 @@ class VertexArray;
 class Context;
 struct Caps;
 
-typedef std::map<GLenum, BindingPointer<Texture>> TextureMap;
-
 class State : public OnAttachmentDirtyReceiver, angle::NonCopyable
 {
   public:

src/libANGLE/angletypes.h

@@ -17,6 +17,7 @@
 #include <stdint.h>
 
 #include <bitset>
+#include <map>
 #include <unordered_map>
 
 namespace gl
@@ -327,6 +328,9 @@ using DrawBufferMask = angle::BitSet<IMPLEMENTATION_MAX_DRAW_BUFFERS>;
 using ContextID = uintptr_t;
 
 constexpr size_t CUBE_FACE_COUNT = 6;
+
+using TextureMap = std::map<GLenum, BindingPointer<Texture>>;
+
 }  // namespace gl
 
 namespace rx

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -51,12 +51,7 @@ RendererD3D::~RendererD3D()
 
 void RendererD3D::cleanup()
 {
-    for (auto &incompleteTexture : mIncompleteTextures)
-    {
-        ANGLE_SWALLOW_ERR(incompleteTexture.second->onDestroy(mDisplay->getProxyContext()));
-        incompleteTexture.second.set(mDisplay->getProxyContext(), nullptr);
-    }
-    mIncompleteTextures.clear();
+    mIncompleteTextures.onDestroy(mDisplay->getProxyContext());
 }
 
 bool RendererD3D::skipDraw(const gl::State &glState, GLenum drawMode)
@@ -87,84 +82,11 @@ bool RendererD3D::skipDraw(const gl::State &glState, GLenum drawMode)
     return false;
 }
 
-size_t RendererD3D::getBoundFramebufferTextures(const gl::ContextState &data,
-                                                FramebufferTextureArray *outTextureArray)
-{
-    size_t textureCount = 0;
-
-    const gl::Framebuffer *drawFramebuffer = data.getState().getDrawFramebuffer();
-    for (size_t i = 0; i < drawFramebuffer->getNumColorBuffers(); i++)
-    {
-        const gl::FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i);
-        if (attachment && attachment->type() == GL_TEXTURE)
-        {
-            (*outTextureArray)[textureCount++] = attachment->getTexture();
-        }
-    }
-
-    const gl::FramebufferAttachment *depthStencilAttachment =
-        drawFramebuffer->getDepthOrStencilbuffer();
-    if (depthStencilAttachment && depthStencilAttachment->type() == GL_TEXTURE)
-    {
-        (*outTextureArray)[textureCount++] = depthStencilAttachment->getTexture();
-    }
-
-    std::sort(outTextureArray->begin(), outTextureArray->begin() + textureCount);
-
-    return textureCount;
-}
-
 gl::Error RendererD3D::getIncompleteTexture(const gl::Context *context,
                                             GLenum type,
                                             gl::Texture **textureOut)
 {
-    if (mIncompleteTextures.find(type) == mIncompleteTextures.end())
-    {
-        GLImplFactory *implFactory = context->getImplementation();
-        const GLubyte color[] = {0, 0, 0, 255};
-        const gl::Extents colorSize(1, 1, 1);
-        const gl::PixelUnpackState unpack(1, 0);
-        const gl::Box area(0, 0, 0, 1, 1, 1);
-
-        // If a texture is external use a 2D texture for the incomplete texture
-        GLenum createType = (type == GL_TEXTURE_EXTERNAL_OES) ? GL_TEXTURE_2D : type;
-
-        // Skip the API layer to avoid needing to pass the Context and mess with dirty bits.
-        gl::Texture *t =
-            new gl::Texture(implFactory, std::numeric_limits<GLuint>::max(), createType);
-        if (createType == GL_TEXTURE_2D_MULTISAMPLE)
-        {
-            ANGLE_TRY(t->setStorageMultisample(nullptr, createType, 1, GL_RGBA8, colorSize, true));
-        }
-        else
-        {
-            ANGLE_TRY(t->setStorage(nullptr, createType, 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++)
-            {
-                ANGLE_TRY(t->getImplementation()->setSubImage(nullptr, face, 0, area, GL_RGBA8,
-                                                              GL_UNSIGNED_BYTE, unpack, color));
-            }
-        }
-        else if (type == GL_TEXTURE_2D_MULTISAMPLE)
-        {
-            gl::ColorF clearValue(0, 0, 0, 1);
-            gl::ImageIndex index = gl::ImageIndex::Make2DMultisample();
-            ANGLE_TRY(GetImplAs<TextureD3D>(t)->clearLevel(context, index, clearValue, 1.0f, 0));
-        }
-        else
-        {
-            ANGLE_TRY(t->getImplementation()->setSubImage(nullptr, createType, 0, area, GL_RGBA8,
-                                                          GL_UNSIGNED_BYTE, unpack, color));
-        }
-        mIncompleteTextures[type].set(context, t);
-    }
-
-    *textureOut = mIncompleteTextures[type].get();
-    return gl::NoError();
+    return mIncompleteTextures.getIncompleteTexture(context, type, this, textureOut);
 }
 
 GLenum RendererD3D::getResetStatus()
@@ -283,6 +205,17 @@ gl::Error RendererD3D::initRenderTarget(RenderTargetD3D *renderTarget)
     return clearRenderTarget(renderTarget, gl::ColorF(0, 0, 0, 0), 1, 0);
 }
 
+gl::Error RendererD3D::initializeMultisampleTextureToBlack(const gl::Context *context,
+                                                           gl::Texture *glTexture)
+{
+    ASSERT(glTexture->getTarget() == GL_TEXTURE_2D_MULTISAMPLE);
+    TextureD3D *textureD3D        = GetImplAs<TextureD3D>(glTexture);
+    gl::ImageIndex index          = gl::ImageIndex::Make2DMultisample();
+    RenderTargetD3D *renderTarget = nullptr;
+    ANGLE_TRY(textureD3D->getRenderTarget(context, index, &renderTarget));
+    return clearRenderTarget(renderTarget, gl::ColorF(0.0f, 0.0f, 0.0f, 1.0f), 1.0f, 0);
+}
+
 unsigned int GetBlendSampleMask(const gl::State &glState, int samples)
 {
     unsigned int mask   = 0;

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -105,10 +105,8 @@ class BufferFactoryD3D : angle::NonCopyable
 };
 
 using AttribIndexArray = std::array<int, gl::MAX_VERTEX_ATTRIBS>;
-using FramebufferTextureArray =
-    std::array<gl::Texture *, gl::IMPLEMENTATION_MAX_FRAMEBUFFER_ATTACHMENTS>;
 
-class RendererD3D : public BufferFactoryD3D
+class RendererD3D : public BufferFactoryD3D, public MultisampleTextureInitializer
 {
   public:
     explicit RendererD3D(egl::Display *display);
@@ -311,9 +309,6 @@ class RendererD3D : public BufferFactoryD3D
 
     angle::WorkerThreadPool *getWorkerThreadPool();
 
-    size_t getBoundFramebufferTextures(const gl::ContextState &data,
-                                       FramebufferTextureArray *outTextureArray);
-
     gl::Error getIncompleteTexture(const gl::Context *context,
                                    GLenum type,
                                    gl::Texture **textureOut);
@@ -322,6 +317,9 @@ class RendererD3D : public BufferFactoryD3D
 
     virtual bool canSelectViewInVertexShader() const = 0;
 
+    gl::Error initializeMultisampleTextureToBlack(const gl::Context *context,
+                                                  gl::Texture *glTexture) override;
+
   protected:
     virtual bool getLUID(LUID *adapterLuid) const = 0;
     virtual void generateCaps(gl::Caps *outCaps,
@@ -331,8 +329,6 @@ class RendererD3D : public BufferFactoryD3D
 
     void cleanup();
 
-    // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
-
     bool skipDraw(const gl::State &glState, GLenum drawMode);
 
     egl::Display *mDisplay;
@@ -350,7 +346,7 @@ class RendererD3D : public BufferFactoryD3D
     mutable gl::Extensions mNativeExtensions;
     mutable gl::Limitations mNativeLimitations;
 
-    gl::TextureMap mIncompleteTextures;
+    IncompleteTextureSet mIncompleteTextures;
 
     mutable bool mWorkaroundsInitialized;
     mutable angle::WorkaroundsD3D mWorkarounds;

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -635,23 +635,6 @@ void TextureD3D::syncState(const gl::Texture::DirtyBits &dirtyBits)
     // TODO(geofflang): Use dirty bits
 }
 
-gl::Error TextureD3D::clearLevel(const gl::Context *context,
-                                 const gl::ImageIndex &index,
-                                 const gl::ColorF &clearColorValue,
-                                 const float clearDepthValue,
-                                 const unsigned int clearStencilValue)
-{
-    TextureStorage *storage = nullptr;
-    ANGLE_TRY(getNativeTexture(context, &storage));
-    RenderTargetD3D *renderTargetD3D = nullptr;
-    ANGLE_TRY(storage->getRenderTarget(context, index, &renderTargetD3D));
-
-    ANGLE_TRY(mRenderer->clearRenderTarget(renderTargetD3D, clearColorValue, clearDepthValue,
-                                           clearStencilValue));
-
-    return gl::NoError();
-}
-
 gl::Error TextureD3D::releaseTexStorage(const gl::Context *context)
 {
     if (!mTexStorage)
@@ -3852,8 +3835,7 @@ bool TextureD3D_2DMultisample::isValidIndex(const gl::ImageIndex &index) const
 
 GLsizei TextureD3D_2DMultisample::getLayerCount(int level) const
 {
-    UNIMPLEMENTED();
-    return GLsizei();
+    return 1;
 }
 
 void TextureD3D_2DMultisample::markAllImagesDirty()

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -100,12 +100,6 @@ class TextureD3D : public TextureImpl
 
     void syncState(const gl::Texture::DirtyBits &dirtyBits) override;
 
-    gl::Error clearLevel(const gl::Context *context,
-                         const gl::ImageIndex &index,
-                         const gl::ColorF &clearColorValue,
-                         const float clearDepthValue,
-                         const unsigned int clearStencilValue);
-
     gl::Error initializeContents(const gl::Context *context,
                                  const gl::ImageIndex &imageIndex) override;
 

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

@@ -2219,10 +2219,7 @@ void StateManager11::setScissorRectD3D(const D3D11_RECT &d3dRect)
 // looks up the corresponding OpenGL texture image unit and texture type,
 // and sets the texture and its addressing/filtering state (or NULL when inactive).
 // Sampler mapping needs to be up-to-date on the program object before this is called.
-gl::Error StateManager11::applyTextures(const gl::Context *context,
-                                        gl::SamplerType shaderType,
-                                        const FramebufferTextureArray &framebufferTextures,
-                                        size_t framebufferTextureCount)
+gl::Error StateManager11::applyTextures(const gl::Context *context, gl::SamplerType shaderType)
 {
     const auto &glState    = context->getGLState();
     const auto &caps       = context->getCaps();
@@ -2231,52 +2228,39 @@ gl::Error StateManager11::applyTextures(const gl::Context *context,
     ASSERT(!programD3D->isSamplerMappingDirty());
 
     // TODO(jmadill): Use the Program's sampler bindings.
-
     const auto &completeTextures = glState.getCompleteTextureCache();
 
     unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType);
     for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
     {
-        GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
         GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, caps);
-        if (textureUnit != -1)
-        {
+        ASSERT(textureUnit != -1);
         gl::Texture *texture = completeTextures[textureUnit];
 
         // A nullptr texture indicates incomplete.
-            if (texture &&
-                !std::binary_search(framebufferTextures.begin(),
-                                    framebufferTextures.begin() + framebufferTextureCount, texture))
+        if (texture)
         {
             gl::Sampler *samplerObject = glState.getSampler(textureUnit);
 
             const gl::SamplerState &samplerState =
                 samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState();
 
-                ANGLE_TRY(
-                    setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
+            ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
             ANGLE_TRY(setTexture(context, shaderType, samplerIndex, texture));
         }
         else
         {
+            GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
+
             // Texture is not sampler complete or it is in use by the framebuffer.  Bind the
             // incomplete texture.
             gl::Texture *incompleteTexture = nullptr;
-                ANGLE_TRY(
-                    mRenderer->getIncompleteTexture(context, textureType, &incompleteTexture));
-
+            ANGLE_TRY(mRenderer->getIncompleteTexture(context, textureType, &incompleteTexture));
             ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture,
                                       incompleteTexture->getSamplerState()));
             ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture));
         }
     }
-        else
-        {
-            // No texture bound to this slot even though it is used by the shader, bind a NULL
-            // texture
-            ANGLE_TRY(setTexture(context, shaderType, samplerIndex, nullptr));
-        }
-    }
 
     // Set all the remaining textures to NULL
     size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? caps.maxTextureImageUnits
@@ -2288,14 +2272,8 @@ gl::Error StateManager11::applyTextures(const gl::Context *context,
 
 gl::Error StateManager11::syncTextures(const gl::Context *context)
 {
-    FramebufferTextureArray framebufferTextures;
-    size_t framebufferSerialCount =
-        mRenderer->getBoundFramebufferTextures(context->getContextState(), &framebufferTextures);
-
-    ANGLE_TRY(
-        applyTextures(context, gl::SAMPLER_VERTEX, framebufferTextures, framebufferSerialCount));
-    ANGLE_TRY(
-        applyTextures(context, gl::SAMPLER_PIXEL, framebufferTextures, framebufferSerialCount));
+    ANGLE_TRY(applyTextures(context, gl::SAMPLER_VERTEX));
+    ANGLE_TRY(applyTextures(context, gl::SAMPLER_PIXEL));
     return gl::NoError();
 }
 

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

@@ -291,10 +291,7 @@ class StateManager11 final : angle::NonCopyable
     gl::Error syncProgram(const gl::Context *context, GLenum drawMode);
 
     gl::Error syncTextures(const gl::Context *context);
-    gl::Error applyTextures(const gl::Context *context,
-                            gl::SamplerType shaderType,
-                            const FramebufferTextureArray &framebufferTextures,
-                            size_t framebufferTextureCount);
+    gl::Error applyTextures(const gl::Context *context, gl::SamplerType shaderType);
 
     gl::Error setSamplerState(const gl::Context *context,
                               gl::SamplerType type,

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

@@ -3231,10 +3231,7 @@ gl::Error Renderer9::clearRenderTarget(RenderTargetD3D *renderTarget,
 // looks up the corresponding OpenGL texture image unit and texture type,
 // and sets the texture and its addressing/filtering state (or NULL when inactive).
 // Sampler mapping needs to be up-to-date on the program object before this is called.
-gl::Error Renderer9::applyTextures(const gl::Context *context,
-                                   gl::SamplerType shaderType,
-                                   const FramebufferTextureArray &framebufferTextures,
-                                   size_t framebufferTextureCount)
+gl::Error Renderer9::applyTextures(const gl::Context *context, gl::SamplerType shaderType)
 {
     const auto &glState    = context->getGLState();
     const auto &caps       = context->getCaps();
@@ -3243,51 +3240,39 @@ gl::Error Renderer9::applyTextures(const gl::Context *context,
     ASSERT(!programD3D->isSamplerMappingDirty());
 
     // TODO(jmadill): Use the Program's sampler bindings.
-
     const auto &completeTextures = glState.getCompleteTextureCache();
 
     unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType);
     for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++)
     {
-        GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
         GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, caps);
-        if (textureUnit != -1)
-        {
+        ASSERT(textureUnit != -1);
         gl::Texture *texture = completeTextures[textureUnit];
 
         // A nullptr texture indicates incomplete.
-            if (texture &&
-                !std::binary_search(framebufferTextures.begin(),
-                                    framebufferTextures.begin() + framebufferTextureCount, texture))
+        if (texture)
         {
             gl::Sampler *samplerObject = glState.getSampler(textureUnit);
 
             const gl::SamplerState &samplerState =
                 samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState();
 
-                ANGLE_TRY(
-                    setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
+            ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, texture, samplerState));
             ANGLE_TRY(setTexture(context, shaderType, samplerIndex, texture));
         }
         else
         {
+            GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex);
+
             // Texture is not sampler complete or it is in use by the framebuffer.  Bind the
             // incomplete texture.
             gl::Texture *incompleteTexture = nullptr;
             ANGLE_TRY(getIncompleteTexture(context, textureType, &incompleteTexture));
-
             ANGLE_TRY(setSamplerState(context, shaderType, samplerIndex, incompleteTexture,
                                       incompleteTexture->getSamplerState()));
             ANGLE_TRY(setTexture(context, shaderType, samplerIndex, incompleteTexture));
         }
     }
-        else
-        {
-            // No texture bound to this slot even though it is used by the shader, bind a NULL
-            // texture
-            ANGLE_TRY(setTexture(context, shaderType, samplerIndex, nullptr));
-        }
-    }
 
     // Set all the remaining textures to NULL
     size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? caps.maxTextureImageUnits
@@ -3304,14 +3289,8 @@ gl::Error Renderer9::applyTextures(const gl::Context *context,
 
 gl::Error Renderer9::applyTextures(const gl::Context *context)
 {
-    FramebufferTextureArray framebufferTextures;
-    size_t framebufferSerialCount =
-        getBoundFramebufferTextures(context->getContextState(), &framebufferTextures);
-
-    ANGLE_TRY(
-        applyTextures(context, gl::SAMPLER_VERTEX, framebufferTextures, framebufferSerialCount));
-    ANGLE_TRY(
-        applyTextures(context, gl::SAMPLER_PIXEL, framebufferTextures, framebufferSerialCount));
+    ANGLE_TRY(applyTextures(context, gl::SAMPLER_VERTEX));
+    ANGLE_TRY(applyTextures(context, gl::SAMPLER_PIXEL));
     return gl::NoError();
 }
 

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

@@ -404,10 +404,7 @@ class Renderer9 : public RendererD3D
     gl::Error applyShaders(const gl::Context *context, GLenum drawMode);
 
     gl::Error applyTextures(const gl::Context *context);
-    gl::Error applyTextures(const gl::Context *context,
-                            gl::SamplerType shaderType,
-                            const FramebufferTextureArray &framebufferTextures,
-                            size_t framebufferTextureCount);
+    gl::Error applyTextures(const gl::Context *context, gl::SamplerType shaderType);
 
     void generateCaps(gl::Caps *outCaps,
                       gl::TextureCapsMap *outTextureCaps,

src/libANGLE/renderer/renderer_utils.cpp

@@ -13,7 +13,9 @@
 #include "image_util/imageformats.h"
 
 #include "libANGLE/AttributeMap.h"
+#include "libANGLE/Context.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/Format.h"
 
 #include <string.h>
@@ -470,4 +472,86 @@ void CopyImageCHROMIUM(const uint8_t *sourceData,
     }
 }
 
+// IncompleteTextureSet implementation.
+IncompleteTextureSet::IncompleteTextureSet()
+{
+}
+
+IncompleteTextureSet::~IncompleteTextureSet()
+{
+}
+
+void IncompleteTextureSet::onDestroy(const gl::Context *context)
+{
+    // Clear incomplete textures.
+    for (auto &incompleteTexture : mIncompleteTextures)
+    {
+        ANGLE_SWALLOW_ERR(incompleteTexture.second->onDestroy(context));
+        incompleteTexture.second.set(context, nullptr);
+    }
+    mIncompleteTextures.clear();
+}
+
+gl::Error IncompleteTextureSet::getIncompleteTexture(
+    const gl::Context *context,
+    GLenum type,
+    MultisampleTextureInitializer *multisampleInitializer,
+    gl::Texture **textureOut)
+{
+    auto iter = mIncompleteTextures.find(type);
+    if (iter != mIncompleteTextures.end())
+    {
+        *textureOut = iter->second.get();
+        return gl::NoError();
+    }
+
+    ContextImpl *implFactory = context->getImplementation();
+
+    const GLubyte color[] = {0, 0, 0, 255};
+    const gl::Extents colorSize(1, 1, 1);
+    const gl::PixelUnpackState unpack(1, 0);
+    const gl::Box area(0, 0, 0, 1, 1, 1);
+
+    // If a texture is external use a 2D texture for the incomplete texture
+    GLenum createType = (type == GL_TEXTURE_EXTERNAL_OES) ? GL_TEXTURE_2D : type;
+
+    gl::Texture *tex = new gl::Texture(implFactory, std::numeric_limits<GLuint>::max(), createType);
+    angle::UniqueObjectPointer<gl::Texture, gl::Context> t(tex, context);
+
+    if (createType == GL_TEXTURE_2D_MULTISAMPLE)
+    {
+        ANGLE_TRY(t->setStorageMultisample(context, createType, 1, GL_RGBA8, colorSize, true));
+    }
+    else
+    {
+        ANGLE_TRY(t->setStorage(context, createType, 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++)
+        {
+            ANGLE_TRY(
+                t->setSubImage(context, unpack, face, 0, area, GL_RGBA, GL_UNSIGNED_BYTE, color));
+        }
+    }
+    else if (type == GL_TEXTURE_2D_MULTISAMPLE)
+    {
+        // Call a specialized clear function to init a multisample texture.
+        ANGLE_TRY(multisampleInitializer->initializeMultisampleTextureToBlack(context, t.get()));
+    }
+    else
+    {
+        ANGLE_TRY(
+            t->setSubImage(context, unpack, createType, 0, area, GL_RGBA, GL_UNSIGNED_BYTE, color));
+    }
+
+    t->syncState();
+
+    mIncompleteTextures[type].set(context, t.release());
+    *textureOut = mIncompleteTextures[type].get();
+    return gl::NoError();
+}
+
 }  // namespace rx

src/libANGLE/renderer/renderer_utils.h

@@ -217,6 +217,37 @@ void CopyImageCHROMIUM(const uint8_t *sourceData,
                        bool unpackPremultiplyAlpha,
                        bool unpackUnmultiplyAlpha);
 
+// Incomplete textures are 1x1 textures filled with black, used when samplers are incomplete.
+// This helper class encapsulates handling incomplete textures. Because the GL back-end
+// can take advantage of the driver's incomplete textures, and because clearing multisample
+// textures is so difficult, we can keep an instance of this class in the back-end instead
+// of moving the logic to the Context front-end.
+
+// This interface allows us to call-back to init a multisample texture.
+class MultisampleTextureInitializer
+{
+  public:
+    virtual gl::Error initializeMultisampleTextureToBlack(const gl::Context *context,
+                                                          gl::Texture *glTexture) = 0;
+};
+
+class IncompleteTextureSet final : angle::NonCopyable
+{
+  public:
+    IncompleteTextureSet();
+    ~IncompleteTextureSet();
+
+    void onDestroy(const gl::Context *context);
+
+    gl::Error getIncompleteTexture(const gl::Context *context,
+                                   GLenum type,
+                                   MultisampleTextureInitializer *multisampleInitializer,
+                                   gl::Texture **textureOut);
+
+  private:
+    gl::TextureMap mIncompleteTextures;
+};
+
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_RENDERER_UTILS_H_