Vulkan: Make texture syncState aware of upcoming generateMipmap

ShabbyX · Commit Bot · commit b772a955e70c · 2020-06-20T04:14:48.000Z
By letting TextureVk::syncState know it's being called for generateMipmap, it can make a better decision to initialize the image: - Staged updates to mips that are going to be overwritten are dropped - The image is created with full mipchain to avoid a redefine in the following generateMipmap() call. Bug: angleproject:4551 Change-Id: Ic70ee6c0a0b29c7bd62beaff612b2f2d5276defb Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2249340 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Jamie Madill <jmadill@chromium.org> Reviewed-by: Tim Van Patten <timvp@google.com>
diff --git a/src/libANGLE/State.cpp b/src/libANGLE/State.cpp
@@ -3132,7 +3132,7 @@ angle::Result State::syncTextures(const Context *context)
         Texture *texture = mActiveTexturesCache[textureIndex];
         if (texture && texture->hasAnyDirtyBit())
         {
-            ANGLE_TRY(texture->syncState(context));
+            ANGLE_TRY(texture->syncState(context, TextureCommand::Other));
         }
     }
 
@@ -3150,7 +3150,7 @@ angle::Result State::syncImages(const Context *context)
         Texture *texture = mImageUnits[imageUnitIndex].texture.get();
         if (texture && texture->hasAnyDirtyBit())
         {
-            ANGLE_TRY(texture->syncState(context));
+            ANGLE_TRY(texture->syncState(context, TextureCommand::Other));
         }
     }
 
@@ -3306,7 +3306,7 @@ angle::Result State::onProgramExecutableChange(const Context *context, Program *
 
         if (image->hasAnyDirtyBit())
         {
-            ANGLE_TRY(image->syncState(context));
+            ANGLE_TRY(image->syncState(context, TextureCommand::Other));
         }
 
         if (mRobustResourceInit && image->initState() == InitState::MayNeedInit)
@@ -3351,7 +3351,7 @@ angle::Result State::onProgramPipelineExecutableChange(const Context *context,
 
         if (image->hasAnyDirtyBit())
         {
-            ANGLE_TRY(image->syncState(context));
+            ANGLE_TRY(image->syncState(context, TextureCommand::Other));
         }
 
         if (mRobustResourceInit && image->initState() == InitState::MayNeedInit)
diff --git a/src/libANGLE/Texture.cpp b/src/libANGLE/Texture.cpp
@@ -1501,10 +1501,7 @@ angle::Result Texture::generateMipmap(Context *context)
         return angle::Result::Continue;
     }
 
-    if (hasAnyDirtyBit())
-    {
-        ANGLE_TRY(syncState(context));
-    }
+    ANGLE_TRY(syncState(context, TextureCommand::GenerateMipmap));
 
     // Clear the base image(s) immediately if needed
     if (context->isRobustResourceInitEnabled())
@@ -1526,7 +1523,7 @@ angle::Result Texture::generateMipmap(Context *context)
 
     ANGLE_TRY(mTexture->generateMipmap(context));
 
-    // Propagate the format and size of the bsae mip to the smaller ones. Cube maps are guaranteed
+    // Propagate the format and size of the base mip to the smaller ones. Cube maps are guaranteed
     // to have faces of the same size and format so any faces can be picked.
     const ImageDesc &baseImageInfo = mState.getImageDesc(mState.getBaseImageTarget(), baseLevel);
     mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format,
@@ -1787,10 +1784,10 @@ GLuint Texture::getNativeID() const
     return mTexture->getNativeID();
 }
 
-angle::Result Texture::syncState(const Context *context)
+angle::Result Texture::syncState(const Context *context, TextureCommand source)
 {
-    ASSERT(hasAnyDirtyBit());
-    ANGLE_TRY(mTexture->syncState(context, mDirtyBits));
+    ASSERT(hasAnyDirtyBit() || source == TextureCommand::GenerateMipmap);
+    ANGLE_TRY(mTexture->syncState(context, mDirtyBits, source));
     mDirtyBits.reset();
     return angle::Result::Continue;
 }
@@ -2006,7 +2003,7 @@ angle::Result Texture::getTexImage(const Context *context,
 {
     if (hasAnyDirtyBit())
     {
-        ANGLE_TRY(syncState(context));
+        ANGLE_TRY(syncState(context, TextureCommand::Other));
     }
 
     return mTexture->getTexImage(context, packState, packBuffer, target, level, format, type,
diff --git a/src/libANGLE/Texture.h b/src/libANGLE/Texture.h
@@ -99,6 +99,14 @@ struct ContextBindingCount
     uint32_t imageBindingCount;
 };
 
+// The source of the syncState call.  Knowing why syncState is being called can help the back-end
+// make more-informed decisions.
+enum class TextureCommand
+{
+    GenerateMipmap,
+    Other,
+};
+
 // State from Table 6.9 (state per texture object) in the OpenGL ES 3.0.2 spec.
 class TextureState final : private angle::NonCopyable
 {
@@ -580,7 +588,7 @@ class Texture final : public RefCountObject<TextureID>,
     };
     using DirtyBits = angle::BitSet<DIRTY_BIT_COUNT>;
 
-    angle::Result syncState(const Context *context);
+    angle::Result syncState(const Context *context, TextureCommand source);
     bool hasAnyDirtyBit() const { return mDirtyBits.any(); }
 
     // ObserverInterface implementation.
diff --git a/src/libANGLE/renderer/TextureImpl.h b/src/libANGLE/renderer/TextureImpl.h
@@ -187,7 +187,8 @@ class TextureImpl : public FramebufferAttachmentObjectImpl
     virtual GLint getNativeID() const;
 
     virtual angle::Result syncState(const gl::Context *context,
-                                    const gl::Texture::DirtyBits &dirtyBits) = 0;
+                                    const gl::Texture::DirtyBits &dirtyBits,
+                                    gl::TextureCommand source) = 0;
 
     virtual GLenum getColorReadFormat(const gl::Context *context);
     virtual GLenum getColorReadType(const gl::Context *context);
diff --git a/src/libANGLE/renderer/TextureImpl_mock.h b/src/libANGLE/renderer/TextureImpl_mock.h
@@ -129,7 +129,10 @@ class MockTextureImpl : public TextureImpl
 
     MOCK_METHOD2(setBaseLevel, angle::Result(const gl::Context *, GLuint));
 
-    MOCK_METHOD2(syncState, angle::Result(const gl::Context *, const gl::Texture::DirtyBits &));
+    MOCK_METHOD3(syncState,
+                 angle::Result(const gl::Context *,
+                               const gl::Texture::DirtyBits &,
+                               gl::TextureCommand source));
 
     MOCK_METHOD0(destructor, void());
 
diff --git a/src/libANGLE/renderer/d3d/TextureD3D.cpp b/src/libANGLE/renderer/d3d/TextureD3D.cpp
@@ -681,7 +681,8 @@ angle::Result TextureD3D::setBaseLevel(const gl::Context *context, GLuint baseLe
 }
 
 angle::Result TextureD3D::syncState(const gl::Context *context,
-                                    const gl::Texture::DirtyBits &dirtyBits)
+                                    const gl::Texture::DirtyBits &dirtyBits,
+                                    gl::TextureCommand source)
 {
     // This could be improved using dirty bits.
     return angle::Result::Continue;
diff --git a/src/libANGLE/renderer/d3d/TextureD3D.h b/src/libANGLE/renderer/d3d/TextureD3D.h
@@ -107,7 +107,8 @@ class TextureD3D : public TextureImpl, public angle::ObserverInterface
     angle::Result setBaseLevel(const gl::Context *context, GLuint baseLevel) override;
 
     angle::Result syncState(const gl::Context *context,
-                            const gl::Texture::DirtyBits &dirtyBits) override;
+                            const gl::Texture::DirtyBits &dirtyBits,
+                            gl::TextureCommand source) override;
 
     angle::Result initializeContents(const gl::Context *context,
                                      const gl::ImageIndex &imageIndex) override;
diff --git a/src/libANGLE/renderer/gl/TextureGL.cpp b/src/libANGLE/renderer/gl/TextureGL.cpp
@@ -1382,7 +1382,8 @@ GLint TextureGL::getNativeID() const
 }
 
 angle::Result TextureGL::syncState(const gl::Context *context,
-                                   const gl::Texture::DirtyBits &dirtyBits)
+                                   const gl::Texture::DirtyBits &dirtyBits,
+                                   gl::TextureCommand source)
 {
     if (dirtyBits.none() && mLocalDirtyBits.none())
     {
diff --git a/src/libANGLE/renderer/gl/TextureGL.h b/src/libANGLE/renderer/gl/TextureGL.h
@@ -190,7 +190,8 @@ class TextureGL : public TextureImpl
     gl::TextureType getType() const;
 
     angle::Result syncState(const gl::Context *context,
-                            const gl::Texture::DirtyBits &dirtyBits) override;
+                            const gl::Texture::DirtyBits &dirtyBits,
+                            gl::TextureCommand source) override;
     bool hasAnyDirtyBit() const;
 
     angle::Result setBaseLevel(const gl::Context *context, GLuint baseLevel) override;
diff --git a/src/libANGLE/renderer/metal/TextureMtl.h b/src/libANGLE/renderer/metal/TextureMtl.h
@@ -131,7 +131,8 @@ class TextureMtl : public TextureImpl
                                             FramebufferAttachmentRenderTarget **rtOut) override;
 
     angle::Result syncState(const gl::Context *context,
-                            const gl::Texture::DirtyBits &dirtyBits) override;
+                            const gl::Texture::DirtyBits &dirtyBits,
+                            gl::TextureCommand source) override;
 
     angle::Result setStorageMultisample(const gl::Context *context,
                                         gl::TextureType type,
diff --git a/src/libANGLE/renderer/metal/TextureMtl.mm b/src/libANGLE/renderer/metal/TextureMtl.mm
@@ -813,7 +813,8 @@ GLuint GetImageLayerIndex(const gl::ImageIndex &index)
 }
 
 angle::Result TextureMtl::syncState(const gl::Context *context,
-                                    const gl::Texture::DirtyBits &dirtyBits)
+                                    const gl::Texture::DirtyBits &dirtyBits,
+                                    gl::TextureCommand source)
 {
     if (dirtyBits.any())
     {
diff --git a/src/libANGLE/renderer/null/TextureNULL.cpp b/src/libANGLE/renderer/null/TextureNULL.cpp
@@ -173,7 +173,8 @@ angle::Result TextureNULL::releaseTexImage(const gl::Context *context)
 }
 
 angle::Result TextureNULL::syncState(const gl::Context *context,
-                                     const gl::Texture::DirtyBits &dirtyBits)
+                                     const gl::Texture::DirtyBits &dirtyBits,
+                                     gl::TextureCommand source)
 {
     return angle::Result::Continue;
 }
diff --git a/src/libANGLE/renderer/null/TextureNULL.h b/src/libANGLE/renderer/null/TextureNULL.h
@@ -118,7 +118,8 @@ class TextureNULL : public TextureImpl
     angle::Result releaseTexImage(const gl::Context *context) override;
 
     angle::Result syncState(const gl::Context *context,
-                            const gl::Texture::DirtyBits &dirtyBits) override;
+                            const gl::Texture::DirtyBits &dirtyBits,
+                            gl::TextureCommand source) override;
 
     angle::Result setStorageMultisample(const gl::Context *context,
                                         gl::TextureType type,
diff --git a/src/libANGLE/renderer/renderer_utils.cpp b/src/libANGLE/renderer/renderer_utils.cpp
@@ -621,7 +621,7 @@ angle::Result IncompleteTextureSet::getIncompleteTexture(
                                  GL_UNSIGNED_BYTE, color));
     }
 
-    ANGLE_TRY(t->syncState(context));
+    ANGLE_TRY(t->syncState(context, gl::TextureCommand::Other));
 
     mIncompleteTextures[type].set(context, t.release());
     *textureOut = mIncompleteTextures[type].get();
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.cpp b/src/libANGLE/renderer/vulkan/TextureVk.cpp
@@ -1156,7 +1156,7 @@ angle::Result TextureVk::redefineLevel(const gl::Context *context,
         // override them with this call.
         uint32_t levelIndexGL = index.getLevelIndex();
         uint32_t layerIndex   = index.hasLayer() ? index.getLayerIndex() : 0;
-        mImage->removeStagedUpdates(contextVk, levelIndexGL, layerIndex);
+        mImage->removeSingleSubresourceStagedUpdates(contextVk, levelIndexGL, layerIndex);
 
         if (mImage->valid())
         {
@@ -1338,41 +1338,17 @@ angle::Result TextureVk::generateMipmapsWithCPU(const gl::Context *context)
 
 angle::Result TextureVk::generateMipmap(const gl::Context *context)
 {
-    ContextVk *contextVk   = vk::GetImpl(context);
-    RendererVk *renderer   = contextVk->getRenderer();
-    bool needRedefineImage = true;
-
-    const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
+    ContextVk *contextVk = vk::GetImpl(context);
+    RendererVk *renderer = contextVk->getRenderer();
 
     // The image should already be allocated by a prior syncState.
     ASSERT(mImage->valid());
 
     // If base level has changed, the front-end should have called syncState already.
     ASSERT(mImage->getBaseLevel() == mState.getEffectiveBaseLevel());
 
-    // Check whether the image is already full mipmap
-    if (mImage->getLevelCount() == getMipLevelCount(ImageMipLevels::FullMipChain))
-    {
-        needRedefineImage = false;
-    }
-
-    // Only staged update here can be the robust resource init.
-    ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
-
-    if (needRedefineImage)
-    {
-        // Redefine the images with mipmaps.
-        // Copy image to the staging buffer and stage an update to the new one.
-        ANGLE_TRY(copyAndStageImageSubresource(contextVk, baseLevelDesc, false,
-                                               getNativeImageLayer(0), 0, mImage->getBaseLevel()));
-
-        // Release the original image and recreate it with new mipmap counts.
-        releaseImage(contextVk);
-
-        mImage->retain(&contextVk->getResourceUseList());
-
-        ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::FullMipChain));
-    }
+    // Only staged update here is the robust resource init if any.
+    ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::FullMipChain));
 
     // Check if the image supports blit. If it does, we can do the mipmap generation on the gpu
     // only.
@@ -1668,7 +1644,8 @@ angle::Result TextureVk::initRenderTargets(ContextVk *contextVk,
 }
 
 angle::Result TextureVk::syncState(const gl::Context *context,
-                                   const gl::Texture::DirtyBits &dirtyBits)
+                                   const gl::Texture::DirtyBits &dirtyBits,
+                                   gl::TextureCommand source)
 {
     ContextVk *contextVk = vk::GetImpl(context);
 
@@ -1679,23 +1656,27 @@ angle::Result TextureVk::syncState(const gl::Context *context,
     if (dirtyBits.test(gl::Texture::DIRTY_BIT_BOUND_AS_IMAGE))
     {
         mImageCreateFlags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
-
-        // Recreate the image to include storage bit if needed.
-        if (!(mImageUsageFlags & VK_IMAGE_USAGE_STORAGE_BIT))
-        {
-            mImageUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT;
-        }
+        mImageUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT;
     }
 
     if (dirtyBits.test(gl::Texture::DIRTY_BIT_SRGB_OVERRIDE))
     {
-        if (!(mImageCreateFlags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) &&
-            mState.getSRGBOverride() != gl::SrgbOverride::Default)
+        if (mState.getSRGBOverride() != gl::SrgbOverride::Default)
         {
             mImageCreateFlags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
         }
     }
 
+    // Before redefining the image for any reason, check to see if it's about to go through mipmap
+    // generation.  In that case, drop every staged change for the subsequent mips after base, and
+    // make sure the image is created with the complete mipchain.
+    bool isGenerateMipmap = source == gl::TextureCommand::GenerateMipmap;
+    if (isGenerateMipmap)
+    {
+        mImage->removeStagedUpdates(contextVk, mState.getEffectiveBaseLevel() + 1,
+                                    mState.getEffectiveMaxLevel());
+    }
+
     // Set base and max level before initializing the image
     if (dirtyBits.test(gl::Texture::DIRTY_BIT_MAX_LEVEL) ||
         dirtyBits.test(gl::Texture::DIRTY_BIT_BASE_LEVEL))
@@ -1715,12 +1696,34 @@ angle::Result TextureVk::syncState(const gl::Context *context,
         ANGLE_TRY(respecifyImageAttributes(contextVk));
     }
 
+    // If generating mipmaps and the image is not full-mip already, make sure it's recreated to the
+    // correct levels.
+    if (isGenerateMipmap && mImage->valid() &&
+        mImage->getLevelCount() != getMipLevelCount(ImageMipLevels::FullMipChain))
+    {
+        // Redefine the image with mipmaps.
+        const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
+
+        // Copy image to the staging buffer and stage an update to the new one.
+        ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
+        ANGLE_TRY(copyAndStageImageSubresource(contextVk, baseLevelDesc, false,
+                                               getNativeImageLayer(0), 0, mImage->getBaseLevel()));
+
+        // Release the original image so it can be recreated with the new mipmap counts.
+        releaseImage(contextVk);
+
+        mImage->retain(&contextVk->getResourceUseList());
+    }
+
     // Initialize the image storage and flush the pixel buffer.
-    ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
+    ANGLE_TRY(ensureImageInitialized(contextVk, isGenerateMipmap ? ImageMipLevels::FullMipChain
+                                                                 : ImageMipLevels::EnabledLevels));
 
     // Mask out the IMPLEMENTATION dirty bit to avoid unnecessary syncs.
     gl::Texture::DirtyBits localBits = dirtyBits;
     localBits.reset(gl::Texture::DIRTY_BIT_IMPLEMENTATION);
+    localBits.reset(gl::Texture::DIRTY_BIT_BASE_LEVEL);
+    localBits.reset(gl::Texture::DIRTY_BIT_MAX_LEVEL);
 
     if (localBits.none() && mSampler.valid())
     {
@@ -1739,20 +1742,16 @@ angle::Result TextureVk::syncState(const gl::Context *context,
         localBits.test(gl::Texture::DIRTY_BIT_SWIZZLE_ALPHA) ||
         localBits.test(gl::Texture::DIRTY_BIT_SRGB_OVERRIDE))
     {
-        if (mImage && mImage->valid())
-        {
-            // We use a special layer count here to handle EGLImages. They might only be
-            // looking at one layer of a cube or 2D array texture.
-            uint32_t layerCount =
-                mState.getType() == gl::TextureType::_2D ? 1 : mImage->getLayerCount();
+        // We use a special layer count here to handle EGLImages. They might only be
+        // looking at one layer of a cube or 2D array texture.
+        uint32_t layerCount =
+            mState.getType() == gl::TextureType::_2D ? 1 : mImage->getLayerCount();
 
-            mImageViews.release(renderer);
-            const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
+        mImageViews.release(renderer);
+        const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
 
-            ANGLE_TRY(initImageViews(contextVk, mImage->getFormat(),
-                                     baseLevelDesc.format.info->sized, mImage->getLevelCount(),
-                                     layerCount));
-        }
+        ANGLE_TRY(initImageViews(contextVk, mImage->getFormat(), baseLevelDesc.format.info->sized,
+                                 mImage->getLevelCount(), layerCount));
     }
 
     vk::SamplerDesc samplerDesc(mState.getSamplerState(), mState.isStencilMode());
diff --git a/src/libANGLE/renderer/vulkan/TextureVk.h b/src/libANGLE/renderer/vulkan/TextureVk.h
@@ -140,7 +140,8 @@ class TextureVk : public TextureImpl, public angle::ObserverInterface
                                             FramebufferAttachmentRenderTarget **rtOut) override;
 
     angle::Result syncState(const gl::Context *context,
-                            const gl::Texture::DirtyBits &dirtyBits) override;
+                            const gl::Texture::DirtyBits &dirtyBits,
+                            gl::TextureCommand source) override;
 
     angle::Result setStorageMultisample(const gl::Context *context,
                                         gl::TextureType type,
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.cpp b/src/libANGLE/renderer/vulkan/vk_helpers.cpp
diff --git a/src/libANGLE/renderer/vulkan/vk_helpers.h b/src/libANGLE/renderer/vulkan/vk_helpers.h
diff --git a/src/tests/gl_tests/MipmapTest.cpp b/src/tests/gl_tests/MipmapTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -3132,7 +3132,7 @@ angle::Result State::syncTextures(const Context *context)`
`3132`	`3132`	`Texture *texture = mActiveTexturesCache[textureIndex];`
`3133`	`3133`	`if (texture && texture->hasAnyDirtyBit())`
`3134`	`3134`	`{`
`3135`		`- ANGLE_TRY(texture->syncState(context));`
	`3135`	`+ ANGLE_TRY(texture->syncState(context, TextureCommand::Other));`
`3136`	`3136`	`}`
`3137`	`3137`	`}`
`3138`	`3138`
`@@ -3150,7 +3150,7 @@ angle::Result State::syncImages(const Context *context)`
`3150`	`3150`	`Texture *texture = mImageUnits[imageUnitIndex].texture.get();`
`3151`	`3151`	`if (texture && texture->hasAnyDirtyBit())`
`3152`	`3152`	`{`
`3153`		`- ANGLE_TRY(texture->syncState(context));`
	`3153`	`+ ANGLE_TRY(texture->syncState(context, TextureCommand::Other));`
`3154`	`3154`	`}`
`3155`	`3155`	`}`
`3156`	`3156`
`@@ -3306,7 +3306,7 @@ angle::Result State::onProgramExecutableChange(const Context context, Program `
`3306`	`3306`
`3307`	`3307`	`if (image->hasAnyDirtyBit())`
`3308`	`3308`	`{`
`3309`		`- ANGLE_TRY(image->syncState(context));`
	`3309`	`+ ANGLE_TRY(image->syncState(context, TextureCommand::Other));`
`3310`	`3310`	`}`
`3311`	`3311`
`3312`	`3312`	`if (mRobustResourceInit && image->initState() == InitState::MayNeedInit)`
`@@ -3351,7 +3351,7 @@ angle::Result State::onProgramPipelineExecutableChange(const Context *context,`
`3351`	`3351`
`3352`	`3352`	`if (image->hasAnyDirtyBit())`
`3353`	`3353`	`{`
`3354`		`- ANGLE_TRY(image->syncState(context));`
	`3354`	`+ ANGLE_TRY(image->syncState(context, TextureCommand::Other));`
`3355`	`3355`	`}`
`3356`	`3356`
`3357`	`3357`	`if (mRobustResourceInit && image->initState() == InitState::MayNeedInit)`
Original file line number	Diff line number	Diff line change
`@@ -1501,10 +1501,7 @@ angle::Result Texture::generateMipmap(Context *context)`
`1501`	`1501`	`return angle::Result::Continue;`
`1502`	`1502`	`}`
`1503`	`1503`
`1504`		`- if (hasAnyDirtyBit())`
`1505`		`- {`
`1506`		`- ANGLE_TRY(syncState(context));`
`1507`		`- }`
	`1504`	`+ ANGLE_TRY(syncState(context, TextureCommand::GenerateMipmap));`
`1508`	`1505`
`1509`	`1506`	`// Clear the base image(s) immediately if needed`
`1510`	`1507`	`if (context->isRobustResourceInitEnabled())`
`@@ -1526,7 +1523,7 @@ angle::Result Texture::generateMipmap(Context *context)`
`1526`	`1523`
`1527`	`1524`	`ANGLE_TRY(mTexture->generateMipmap(context));`
`1528`	`1525`
`1529`		`- // Propagate the format and size of the bsae mip to the smaller ones. Cube maps are guaranteed`
	`1526`	`+ // Propagate the format and size of the base mip to the smaller ones. Cube maps are guaranteed`
`1530`	`1527`	`// to have faces of the same size and format so any faces can be picked.`
`1531`	`1528`	`const ImageDesc &baseImageInfo = mState.getImageDesc(mState.getBaseImageTarget(), baseLevel);`
`1532`	`1529`	`mState.setImageDescChain(baseLevel, maxLevel, baseImageInfo.size, baseImageInfo.format,`
`@@ -1787,10 +1784,10 @@ GLuint Texture::getNativeID() const`
`1787`	`1784`	`return mTexture->getNativeID();`
`1788`	`1785`	`}`
`1789`	`1786`
`1790`		`-angle::Result Texture::syncState(const Context *context)`
	`1787`	`+angle::Result Texture::syncState(const Context *context, TextureCommand source)`
`1791`	`1788`	`{`
`1792`		`- ASSERT(hasAnyDirtyBit());`
`1793`		`- ANGLE_TRY(mTexture->syncState(context, mDirtyBits));`
	`1789`	`+ ASSERT(hasAnyDirtyBit() \|\| source == TextureCommand::GenerateMipmap);`
	`1790`	`+ ANGLE_TRY(mTexture->syncState(context, mDirtyBits, source));`
`1794`	`1791`	`mDirtyBits.reset();`
`1795`	`1792`	`return angle::Result::Continue;`
`1796`	`1793`	`}`
`@@ -2006,7 +2003,7 @@ angle::Result Texture::getTexImage(const Context *context,`
`2006`	`2003`	`{`
`2007`	`2004`	`if (hasAnyDirtyBit())`
`2008`	`2005`	`{`
`2009`		`- ANGLE_TRY(syncState(context));`
	`2006`	`+ ANGLE_TRY(syncState(context, TextureCommand::Other));`
`2010`	`2007`	`}`
`2011`	`2008`
`2012`	`2009`	`return mTexture->getTexImage(context, packState, packBuffer, target, level, format, type,`
Original file line number	Diff line number	Diff line change
`@@ -681,7 +681,8 @@ angle::Result TextureD3D::setBaseLevel(const gl::Context *context, GLuint baseLe`
`681`	`681`	`}`
`682`	`682`
`683`	`683`	`angle::Result TextureD3D::syncState(const gl::Context *context,`
`684`		`- const gl::Texture::DirtyBits &dirtyBits)`
	`684`	`+ const gl::Texture::DirtyBits &dirtyBits,`
	`685`	`+ gl::TextureCommand source)`
`685`	`686`	`{`
`686`	`687`	`// This could be improved using dirty bits.`
`687`	`688`	`return angle::Result::Continue;`
Original file line number	Diff line number	Diff line change
`@@ -1382,7 +1382,8 @@ GLint TextureGL::getNativeID() const`
`1382`	`1382`	`}`
`1383`	`1383`
`1384`	`1384`	`angle::Result TextureGL::syncState(const gl::Context *context,`
`1385`		`- const gl::Texture::DirtyBits &dirtyBits)`
	`1385`	`+ const gl::Texture::DirtyBits &dirtyBits,`
	`1386`	`+ gl::TextureCommand source)`
`1386`	`1387`	`{`
`1387`	`1388`	`if (dirtyBits.none() && mLocalDirtyBits.none())`
`1388`	`1389`	`{`