DynamicTextureArray: enforce pending texture array resize invariants

Reject retargeting or cancellation while a default resize is pending,
preserve typed SRVs across repeated resize requests, and handle resizing
an uninitialized array to zero.

Author: TheMostDiligent

Graphics/GraphicsTools/interface/DynamicTextureArray.hpp

@@ -117,6 +117,11 @@ class DynamicTextureArray
     ///
     /// Typically `pContext` is null when the method is called from a worker thread.
     ///
+    /// While a content-preserving resize of a default texture is pending, the
+    /// method may only be called with the same `NewArraySize`, for example to
+    /// provide a device or context that was previously unavailable. A different
+    /// size, including cancellation, is rejected until the pending resize commits.
+    ///
     /// If `NewArraySize` is zero, internal buffer will be released.
     ITexture* Resize(IRenderDevice*  pDevice,
                      IDeviceContext* pContext,

Graphics/GraphicsTools/src/DynamicTextureArray.cpp

@@ -514,6 +514,12 @@ void DynamicTextureArray::CommitResize(IRenderDevice*  pDevice,
     const Uint32 CurrArraySize = GetArraySize();
     if (m_pTexture && CurrArraySize != m_PendingSize)
     {
+        if (GetUsage() == USAGE_DEFAULT && m_pTexture->GetDesc().ArraySize != m_PendingSize)
+        {
+            LOG_ERROR_MESSAGE("Pending texture size does not match the requested array size");
+            return;
+        }
+
         bool ResizeCommitted = false;
         if (GetUsage() == USAGE_SPARSE)
         {
@@ -562,27 +568,26 @@ ITexture* DynamicTextureArray::Resize(IRenderDevice*  pDevice,
                                       Uint32          NewArraySize,
                                       bool            DiscardContent)
 {
+    if (GetUsage() == USAGE_DEFAULT &&
+        m_pStaleTexture != nullptr &&
+        NewArraySize != m_PendingSize)
+    {
+        LOG_ERROR_MESSAGE("A default texture resize is already pending. Commit it before requesting another size.");
+        return m_pTexture;
+    }
+
     if (m_PendingSize != NewArraySize)
     {
         m_PendingSize = NewArraySize;
 
         if (GetUsage() != USAGE_SPARSE)
         {
-            if (!m_pStaleTexture)
-            {
-                // Additional views must not keep the old texture alive after its
-                // ownership is transferred to m_pStaleTexture.
-                ReleaseTextureViews();
-                m_pStaleTexture = std::move(m_pTexture);
-            }
-            else
-            {
-                DEV_CHECK_ERR(!m_pTexture || NewArraySize == 0,
-                              "There is a non-null stale Texture. This likely indicates that "
-                              "Resize() has been called multiple times with different sizes, "
-                              "but copy has not been committed by providing non-null device "
-                              "context to either Resize() or Update()");
-            }
+            VERIFY_EXPR(!m_pStaleTexture);
+
+            // Additional views must not keep the old texture alive after its
+            // ownership is transferred to m_pStaleTexture.
+            ReleaseTextureViews();
+            m_pStaleTexture = std::move(m_pTexture);
 
             if (m_PendingSize == 0)
             {

Tests/DiligentCoreAPITest/src/DynamicTextureArrayTest.cpp

@@ -197,6 +197,52 @@ TEST(DynamicTextureArray, TextureSRVsFollowBackingTexture)
     EXPECT_EQ(TextureArray.GetTextureSRV(TEX_FORMAT_RGBA8_UNORM_SRGB), pResizedSRGBView);
 }
 
+TEST(DynamicTextureArray, PendingResizeRejectsRetargetingAndCancellation)
+{
+    auto* const pEnv     = GPUTestingEnvironment::GetInstance();
+    auto* const pDevice  = pEnv->GetDevice();
+    auto* const pContext = pEnv->GetDeviceContext();
+
+    GPUTestingEnvironment::ScopedReleaseResources AutoreleaseResources;
+
+    DynamicTextureArrayCreateInfo CI;
+    CI.Desc.Format    = TEX_FORMAT_RGBA8_UNORM;
+    CI.Desc.Name      = "Dynamic Texture Array Pending Resize Test";
+    CI.Desc.Type      = RESOURCE_DIM_TEX_2D_ARRAY;
+    CI.Desc.BindFlags = BIND_SHADER_RESOURCE;
+    CI.Desc.Width     = 64;
+    CI.Desc.Height    = 64;
+    CI.Desc.ArraySize = 1;
+    CI.Desc.MipLevels = 1;
+
+    DynamicTextureArray TextureArray{pDevice, CI};
+
+    ITexture* const pPendingTexture = TextureArray.Resize(pDevice, nullptr, 2);
+    ASSERT_NE(pPendingTexture, nullptr);
+    EXPECT_TRUE(TextureArray.PendingUpdate());
+    EXPECT_EQ(TextureArray.GetArraySize(), 1u);
+    EXPECT_EQ(pPendingTexture->GetDesc().ArraySize, 2u);
+
+    // A pending content-preserving resize must be committed before it can be
+    // retargeted or cancelled.
+    {
+        TestingEnvironment::ErrorScope ExpectedErrors{
+            "A default texture resize is already pending",
+            "A default texture resize is already pending"};
+        EXPECT_EQ(TextureArray.Resize(pDevice, nullptr, 3), pPendingTexture);
+        EXPECT_EQ(TextureArray.Resize(nullptr, nullptr, 1), pPendingTexture);
+    }
+
+    EXPECT_TRUE(TextureArray.PendingUpdate());
+    EXPECT_EQ(TextureArray.GetArraySize(), 1u);
+    EXPECT_EQ(TextureArray.GetTexture(), pPendingTexture);
+    EXPECT_EQ(pPendingTexture->GetDesc().ArraySize, 2u);
+
+    EXPECT_EQ(TextureArray.Resize(pDevice, pContext, 2), pPendingTexture);
+    EXPECT_FALSE(TextureArray.PendingUpdate());
+    EXPECT_EQ(TextureArray.GetArraySize(), 2u);
+}
+
 TEST(DynamicTextureArray, TypedSRGBTextureReturnsSRGBView)
 {
     auto* const pDevice = GPUTestingEnvironment::GetInstance()->GetDevice();
@@ -222,6 +268,27 @@ TEST(DynamicTextureArray, TypedSRGBTextureReturnsSRGBView)
     EXPECT_EQ(TextureArray.GetTextureSRV(TEX_FORMAT_RGBA8_UNORM), nullptr);
 }
 
+TEST(DynamicTextureArray, ResizeToZeroBeforeInitialization)
+{
+    DynamicTextureArrayCreateInfo CI;
+    CI.Desc.Format    = TEX_FORMAT_RGBA8_UNORM;
+    CI.Desc.Name      = "Uninitialized Dynamic Texture Array Resize Test";
+    CI.Desc.Type      = RESOURCE_DIM_TEX_2D_ARRAY;
+    CI.Desc.BindFlags = BIND_SHADER_RESOURCE;
+    CI.Desc.Width     = 64;
+    CI.Desc.Height    = 64;
+    CI.Desc.ArraySize = 1;
+    CI.Desc.MipLevels = 1;
+
+    DynamicTextureArray TextureArray{nullptr, CI};
+    ASSERT_TRUE(TextureArray.PendingUpdate());
+
+    EXPECT_EQ(TextureArray.Resize(nullptr, nullptr, 0), nullptr);
+    EXPECT_FALSE(TextureArray.PendingUpdate());
+    EXPECT_EQ(TextureArray.GetArraySize(), 0u);
+    EXPECT_EQ(TextureArray.GetTexture(), nullptr);
+}
+