Remove initialization of ImageD3D objects now that lazy init covers them

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -267,11 +267,6 @@ angle::WorkerThreadPool *RendererD3D::getWorkerThreadPool()
     return &mWorkerThreadPool;
 }
 
-bool RendererD3D::isRobustResourceInitEnabled() const
-{
-    return mDisplay->isRobustResourceInitEnabled();
-}
-
 Serial RendererD3D::generateSerial()
 {
     return mSerialFactory.generate();

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -311,8 +311,6 @@ class RendererD3D : public BufferFactoryD3D
 
     angle::WorkerThreadPool *getWorkerThreadPool();
 
-    bool isRobustResourceInitEnabled() const;
-
     size_t getBoundFramebufferTextures(const gl::ContextState &data,
                                        FramebufferTextureArray *outTextureArray);
 

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -153,11 +153,6 @@ GLint TextureD3D::getBaseLevelDepth() const
     return (baseImage ? baseImage->getDepth() : 0);
 }
 
-bool TextureD3D::shouldForceReleaseImagesOnSetImage(const uint8_t *pixels) const
-{
-    return mRenderer->isRobustResourceInitEnabled() && pixels == nullptr;
-}
-
 // Note: "base level image" is loosely defined to be any image from the base level,
 // where in the base of 2D array textures and cube maps there are several. Don't use
 // the base level image for anything except querying texture format and size.
@@ -849,8 +844,7 @@ gl::Error TextureD3D_2D::setImage(const gl::Context *context,
     bool fastUnpacked = false;
     GLint level       = static_cast<GLint>(imageLevel);
 
-    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size, false));
 
     gl::ImageIndex index = gl::ImageIndex::Make2D(level);
 
@@ -921,8 +915,7 @@ gl::Error TextureD3D_2D::setCompressedImage(const gl::Context *context,
     GLint level = static_cast<GLint>(imageLevel);
 
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size, false));
 
     return setCompressedImageImpl(context, gl::ImageIndex::Make2D(level), unpack, pixels, 0);
 }
@@ -958,7 +951,7 @@ gl::Error TextureD3D_2D::copyImage(const gl::Context *context,
         gl::GetInternalFormatInfo(internalFormat, GL_UNSIGNED_BYTE);
     gl::Extents sourceExtents(origSourceArea.width, origSourceArea.height, 1);
     ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, sourceExtents,
-                            mRenderer->isRobustResourceInitEnabled()));
+                            false));
 
     gl::Extents fbSize = source->getReadColorbuffer()->getSize();
 
@@ -973,7 +966,7 @@ gl::Error TextureD3D_2D::copyImage(const gl::Context *context,
     // TODO(fjhenigman): When robust resource is fully implemented look into making it a
     // prerequisite for WebGL and deleting this code.
     if (outside &&
-        (context->getExtensions().webglCompatibility || mRenderer->isRobustResourceInitEnabled()))
+        (context->getExtensions().webglCompatibility || context->isRobustResourceInitEnabled()))
     {
         angle::MemoryBuffer *zero;
         ANGLE_TRY(context->getZeroFilledBuffer(
@@ -1645,8 +1638,7 @@ gl::Error TextureD3D_Cube::setImage(const gl::Context *context,
     gl::ImageIndex index       = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
 
     ANGLE_TRY(redefineImage(context, index.layerIndex, static_cast<GLint>(level),
-                            internalFormatInfo.sizedInternalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+                            internalFormatInfo.sizedInternalFormat, size, false));
 
     return setImageImpl(context, index, type, unpack, pixels, 0);
 }
@@ -1681,7 +1673,7 @@ gl::Error TextureD3D_Cube::setCompressedImage(const gl::Context *context,
     size_t faceIndex = gl::CubeMapTextureTargetToLayerIndex(target);
 
     ANGLE_TRY(redefineImage(context, static_cast<int>(faceIndex), static_cast<GLint>(level),
-                            internalFormat, size, shouldForceReleaseImagesOnSetImage(pixels)));
+                            internalFormat, size, false));
 
     gl::ImageIndex index = gl::ImageIndex::MakeCube(target, static_cast<GLint>(level));
     return setCompressedImageImpl(context, index, unpack, pixels, 0);
@@ -1719,8 +1711,7 @@ gl::Error TextureD3D_Cube::copyImage(const gl::Context *context,
 
     gl::Extents size(origSourceArea.width, origSourceArea.height, 1);
     ANGLE_TRY(redefineImage(context, static_cast<int>(faceIndex), level,
-                            internalFormatInfo.sizedInternalFormat, size,
-                            mRenderer->isRobustResourceInitEnabled()));
+                            internalFormatInfo.sizedInternalFormat, size, false));
 
     gl::Extents fbSize = source->getReadColorbuffer()->getSize();
 
@@ -1735,7 +1726,7 @@ gl::Error TextureD3D_Cube::copyImage(const gl::Context *context,
     // TODO(fjhenigman): When robust resource is fully implemented look into making it a
     // prerequisite for WebGL and deleting this code.
     if (outside && context->getExtensions().webglCompatibility &&
-        !mRenderer->isRobustResourceInitEnabled())
+        !context->isRobustResourceInitEnabled())
     {
         angle::MemoryBuffer *zero;
         ANGLE_TRY(context->getZeroFilledBuffer(
@@ -2388,8 +2379,7 @@ gl::Error TextureD3D_3D::setImage(const gl::Context *context,
     const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat, type);
 
     GLint level = static_cast<GLint>(imageLevel);
-    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, internalFormatInfo.sizedInternalFormat, size, false));
 
     bool fastUnpacked = false;
 
@@ -2465,8 +2455,7 @@ gl::Error TextureD3D_3D::setCompressedImage(const gl::Context *context,
 
     GLint level = static_cast<GLint>(imageLevel);
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size, false));
 
     gl::ImageIndex index = gl::ImageIndex::Make3D(level);
     return setCompressedImageImpl(context, index, unpack, pixels, 0);
@@ -2935,8 +2924,7 @@ gl::Error TextureD3D_2DArray::setImage(const gl::Context *context,
     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat, type);
 
     GLint level = static_cast<GLint>(imageLevel);
-    ANGLE_TRY(redefineImage(context, level, formatInfo.sizedInternalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, formatInfo.sizedInternalFormat, size, false));
 
     GLsizei inputDepthPitch              = 0;
     ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(type, size.width, size.height, unpack.alignment,
@@ -2999,8 +2987,7 @@ gl::Error TextureD3D_2DArray::setCompressedImage(const gl::Context *context,
 
     GLint level = static_cast<GLint>(imageLevel);
     // compressed formats don't have separate sized internal formats-- we can just use the compressed format directly
-    ANGLE_TRY(redefineImage(context, level, internalFormat, size,
-                            shouldForceReleaseImagesOnSetImage(pixels)));
+    ANGLE_TRY(redefineImage(context, level, internalFormat, size, false));
 
     const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalFormat);
     GLsizei inputDepthPitch              = 0;

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -173,8 +173,6 @@ class TextureD3D : public TextureImpl
 
     GLint getBaseLevelDepth() const;
 
-    bool shouldForceReleaseImagesOnSetImage(const uint8_t *pixels) const;
-
     RendererD3D *mRenderer;
 
     bool mDirtyImages;

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

@@ -137,8 +137,7 @@ bool Image11::isDirty() const
     // recovered from TextureStorage AND the texture doesn't require init data (i.e. a blank new
     // texture will suffice) AND robust resource initialization is not enabled then isDirty should
     // still return false.
-    if (mDirty && !mStagingTexture.valid() && !mRecoverFromStorage &&
-        !mRenderer->isRobustResourceInitEnabled())
+    if (mDirty && !mStagingTexture.valid() && !mRecoverFromStorage)
     {
         const Renderer11DeviceCaps &deviceCaps = mRenderer->getRenderer11DeviceCaps();
         const auto &formatInfo                 = d3d11::Format::Get(mInternalFormat, deviceCaps);
@@ -255,8 +254,7 @@ bool Image11::redefine(GLenum target,
         mRenderable = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN);
 
         releaseStagingTexture();
-        mDirty = (formatInfo.dataInitializerFunction != nullptr) ||
-                 mRenderer->isRobustResourceInitEnabled();
+        mDirty = (formatInfo.dataInitializerFunction != nullptr);
 
         return true;
     }

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

@@ -845,6 +845,8 @@ egl::Error Renderer11::initializeD3DDevice()
         mRenderer11DeviceCaps.featureLevel = mDevice->GetFeatureLevel();
     }
 
+    mResourceManager11.setAllocationsInitialized(mCreateDebugDevice);
+
     d3d11::SetDebugName(mDeviceContext, "DeviceContext");
 
     return egl::NoError();

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

@@ -17,6 +17,12 @@ namespace rx
 
 namespace
 {
+
+constexpr uint8_t kDebugInitTextureDataValue = 0x48;
+constexpr FLOAT kDebugColorInitClearValue[4] = {0.3f, 0.5f, 0.7f, 0.5f};
+constexpr FLOAT kDebugDepthInitValue         = 0.2f;
+constexpr UINT8 kDebugStencilInitValue       = 3;
+
 size_t ComputeMippedMemoryUsage(unsigned int width,
                                 unsigned int height,
                                 unsigned int depth,
@@ -283,7 +289,8 @@ gl::Error ClearResource(Renderer11 *renderer,
             d3d11::DepthStencilView dsv;
             ANGLE_TRY(renderer->allocateResource(dsvDesc, texture, &dsv));
 
-            context->ClearDepthStencilView(dsv.get(), clearFlags, 1.0f, 0);
+            context->ClearDepthStencilView(dsv.get(), clearFlags, kDebugDepthInitValue,
+                                           kDebugStencilInitValue);
         }
     }
     else
@@ -292,8 +299,7 @@ gl::Error ClearResource(Renderer11 *renderer,
         d3d11::RenderTargetView rtv;
         ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
 
-        const FLOAT zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-        context->ClearRenderTargetView(rtv.get(), zero);
+        context->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
     }
 
     return gl::NoError();
@@ -312,8 +318,7 @@ gl::Error ClearResource(Renderer11 *renderer,
     d3d11::RenderTargetView rtv;
     ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
 
-    const FLOAT zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-    context->ClearRenderTargetView(rtv.get(), zero);
+    context->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
     return gl::NoError();
 }
 
@@ -328,7 +333,9 @@ static_assert(kResourceTypeNames[NumResourceTypes - 1] != nullptr,
 
 // ResourceManager11 Implementation.
 ResourceManager11::ResourceManager11()
-    : mAllocatedResourceCounts({{}}), mAllocatedResourceDeviceMemory({{}})
+    : mInitializeAllocations(false),
+      mAllocatedResourceCounts({{}}),
+      mAllocatedResourceDeviceMemory({{}})
 {
 }
 
@@ -355,7 +362,7 @@ gl::Error ResourceManager11::allocate(Renderer11 *renderer,
     T *resource          = nullptr;
 
     GetInitDataFromD3D11<T> *shadowInitData = initData;
-    if (!shadowInitData && renderer->isRobustResourceInitEnabled())
+    if (!shadowInitData && mInitializeAllocations)
     {
         shadowInitData = createInitDataIfNeeded<T>(desc);
     }
@@ -373,7 +380,7 @@ gl::Error ResourceManager11::allocate(Renderer11 *renderer,
                                  << gl::FmtHR(hr);
     }
 
-    if (!shadowInitData && renderer->isRobustResourceInitEnabled())
+    if (!shadowInitData && mInitializeAllocations)
     {
         ANGLE_TRY(ClearResource(renderer, desc, resource));
     }
@@ -420,7 +427,7 @@ const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Te
     if (mZeroMemory.size() < requiredSize)
     {
         mZeroMemory.resize(requiredSize);
-        mZeroMemory.fill(0);
+        mZeroMemory.fill(kDebugInitTextureDataValue);
     }
 
     const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format);
@@ -466,7 +473,7 @@ const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Te
     if (mZeroMemory.size() < requiredSize)
     {
         mZeroMemory.resize(requiredSize);
-        mZeroMemory.fill(0);
+        mZeroMemory.fill(kDebugInitTextureDataValue);
     }
 
     const auto &formatSizeInfo = d3d11::GetDXGIFormatSizeInfo(desc->Format);
@@ -500,6 +507,11 @@ GetInitDataFromD3D11<T> *ResourceManager11::createInitDataIfNeeded(const GetDesc
     return nullptr;
 }
 
+void ResourceManager11::setAllocationsInitialized(bool initialize)
+{
+    mInitializeAllocations = initialize;
+}
+
 #define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE)  \
     \
 template \

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

@@ -317,6 +317,8 @@ class ResourceManager11 final : angle::NonCopyable
 
     void onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource);
 
+    void setAllocationsInitialized(bool initialize);
+
   private:
     void incrResource(ResourceType resourceType, size_t memorySize);
     void decrResource(ResourceType resourceType, size_t memorySize);
@@ -324,6 +326,8 @@ class ResourceManager11 final : angle::NonCopyable
     template <typename T>
     GetInitDataFromD3D11<T> *createInitDataIfNeeded(const GetDescFromD3D11<T> *desc);
 
+    bool mInitializeAllocations;
+
     std::array<size_t, NumResourceTypes> mAllocatedResourceCounts;
     std::array<size_t, NumResourceTypes> mAllocatedResourceDeviceMemory;
     angle::MemoryBuffer mZeroMemory;