fix: D3D12 skip upload/readback resources by heap type, not state

TransitionDescriptorResources skipped resources whose NativeResourceState
was GenericRead or CopyDest, treating those states as upload/readback
heap markers. That conflates heap type (a lifetime property of Upload/
Readback heaps) with transient state (a Default-heap resource can be in
CopyDest after a Copy/Resolve/UpdateSubresource). The skip silently
dropped the binding-time transition and left stale layouts leaking into
the next SRV/Present — D3D12 GPU validation 'Incompatible texture
barrier layout', SRV sampling in LEGACY_COPY_DEST, WARP 1.0.18 missing
glyphs in dynamic sprite font tests, back-buffer Present failing in
COPY_SOURCE on RenderToWindow.

Track heap type explicitly: add IsHostVisibleHeap on GraphicsResource,
set at resource creation (Upload/Readback → true, Default → false). Draw
prep skips on that flag, not on state. Default-heap resources in
CopyDest/CopySource/GenericRead after a copy go through the normal
transition to ShaderResource at next bind — single barrier, no reliance
on a post-copy Common transition and on barrier coalescing to merge it.

Author: xen2

sources/engine/Stride.Graphics/Direct3D12/Buffer.Direct3D12.cs

@@ -176,6 +176,7 @@ public void Recreate(IntPtr dataPointer)
                 NativeResourceState |= ResourceStates.IndirectArgument;
 
             var heapType = HeapType.Default;
+            IsHostVisibleHeap = false;
             if (Usage == GraphicsResourceUsage.Staging)
             {
                 // Per our own definition of staging resource (read-back only)
@@ -184,11 +185,13 @@ public void Recreate(IntPtr dataPointer)
 
                 heapType = HeapType.Readback;
                 NativeResourceState = ResourceStates.CopyDest;
+                IsHostVisibleHeap = true;
             }
             else if (Usage == GraphicsResourceUsage.Dynamic)
             {
                 heapType = HeapType.Upload;
                 NativeResourceState = ResourceStates.GenericRead;
+                IsHostVisibleHeap = true;
             }
 
             // TODO: D3D12: Move to a global allocator in bigger committed resources

sources/engine/Stride.Graphics/Direct3D12/CommandList.Direct3D12.cs

@@ -430,9 +430,11 @@ private void TransitionDescriptorResources()
                     if (resource is null)
                         continue;
 
-                    // Skip resources on upload/readback heaps (GenericRead/CopyDest) — they can't be transitioned
-                    if (resource.NativeResourceState == ResourceStates.GenericRead ||
-                        resource.NativeResourceState == ResourceStates.CopyDest)
+                    // Skip resources on CPU-visible heaps (Upload/Readback) — they have a fixed
+                    // D3D12 state for their lifetime and cannot be transitioned. Must check by heap
+                    // type, not by state: default-heap resources can be in CopyDest/GenericRead
+                    // transiently after a copy and must still go through the transition.
+                    if (resource.IsHostVisibleHeap)
                         continue;
 
                     if (isUAV[j])

sources/engine/Stride.Graphics/Direct3D12/GraphicsResource.Direct3D12.cs

@@ -36,6 +36,16 @@ public abstract partial class GraphicsResource
         /// </summary>
         internal ResourceStates NativeResourceState;
 
+        /// <summary>
+        ///   Whether this resource is on a CPU-visible heap (Upload or Readback).
+        ///   Resources on these heaps have a fixed D3D12 state (<see cref="ResourceStates.GenericRead"/>
+        ///   or <see cref="ResourceStates.CopyDest"/>) for their lifetime and cannot be transitioned —
+        ///   lazy barrier code must skip them. This is a heap-type property; don't confuse it with the
+        ///   transient <see cref="NativeResourceState"/> (default-heap resources can legitimately be in
+        ///   CopyDest after a copy).
+        /// </summary>
+        internal bool IsHostVisibleHeap;
+
         /// <summary>
         ///   Gets a value indicating whether the Graphics Resource is in "Debug mode".
         /// </summary>
@@ -75,6 +85,7 @@ internal override void SwapInternal(GraphicsResourceBase other)
             (NativeShaderResourceView, otherResource.NativeShaderResourceView)   = (otherResource.NativeShaderResourceView, NativeShaderResourceView);
             (NativeUnorderedAccessView, otherResource.NativeUnorderedAccessView) = (otherResource.NativeUnorderedAccessView, NativeUnorderedAccessView);
             (NativeResourceState, otherResource.NativeResourceState)             = (otherResource.NativeResourceState, NativeResourceState);
+            (IsHostVisibleHeap, otherResource.IsHostVisibleHeap)                 = (otherResource.IsHostVisibleHeap, IsHostVisibleHeap);
         }
     }
 }

sources/engine/Stride.Graphics/Direct3D12/Texture.Direct3D12.cs

@@ -228,6 +228,7 @@ private partial void InitializeFromImpl(DataBox[] dataBoxes)
             void InitializeStagingTexture()
             {
                 NativeResourceState = ResourceStates.CopyDest;
+                IsHostVisibleHeap = true;
                 LayoutTracker.Initialize(BarrierLayout.CopyDest, ArraySize * MipLevelCount);
                 NativeTextureDescription = GetTextureDescription(Dimension);