refactor: name the Direct3D12 transition pass after Direct3D12 concepts

Review feedback from @Ethereal77 on #3329.

"Attachment" is a Vulkan term. Direct3D12 has a resource, a view, and a barrier
that says how the resource is used. IsBoundAsAttachment becomes
IsBoundAsRenderTargetOrDepth, and the comment beside it drops the same word.

The type test moves from that helper to the loop that calls it. A reader of the
loop now sees which resources the pass acts on, and the helper takes a Texture,
so the question of what happens to a Buffer no longer arises at the call site.

Buffers stay out of scope, which matches the Vulkan pass. That pass skips any
descriptor that is not a sampled or storage image. A buffer barrier also
replaces the whole access mask, and nothing restores the vertex, index or
constant buffer access a buffer may still need, because binding those emits no
barrier. Covering buffers means combining every access a buffer is currently
bound for, and both backends should gain that together.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: sasvdw

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

@@ -406,20 +406,20 @@ private void PrepareDraw(bool isDispatch = false)
         }
 
         /// <summary>
-        ///   Transitions every Graphics Resource bound in a Descriptor Set to the state its use needs.
+        ///   Transitions every Texture bound in a Descriptor Set to the state its use needs.
         /// </summary>
         /// <remarks>
         ///   <para>
-        ///     Explicit transitions at pass boundaries remain the norm, because only a pass knows
-        ///     enough about its own inputs and outputs to batch them. This pass is the floor beneath
-        ///     that, for generic code such as <c>ComputeEffectShader</c> that binds an unordered
-        ///     access view and declares no transition of its own.
-        ///   </para>
-        ///   <para>
         ///     The pass is idempotent. <see cref="ResourceBarrierTransition"/> returns early when the
         ///     tracked layout already matches, so a resource an explicit transition already moved
         ///     costs nothing here.
         ///   </para>
+        ///   <para>
+        ///     Buffers are out of scope, which matches the Vulkan pass. A buffer barrier replaces the
+        ///     whole access mask, and nothing restores the vertex, index or constant buffer access a
+        ///     buffer may still need, because binding those emits no barrier. Covering buffers means
+        ///     combining every access a buffer is currently bound for, on both backends together.
+        ///   </para>
         /// </remarks>
         private void TransitionBoundResources()
         {
@@ -436,27 +436,23 @@ private void TransitionBoundResources()
                 int slotCount = descriptorSet.Description.SrvCount;
                 for (int slot = 0; slot < slotCount; slot++)
                 {
-                    var resource = tracking.Resources[slot];
-                    if (resource is null)
+                    if (tracking.Resources[slot] is not Texture texture)
                         continue;
 
-                    // An attachment the pipeline is about to write keeps its attachment state. Its
-                    // producer already transitioned it, and moving it here would invalidate the draw.
-                    if (IsBoundAsAttachment(resource))
+                    // A render target or depth buffer the pipeline is about to write keeps the state
+                    // its producer set. Moving it here would invalidate the draw.
+                    if (IsBoundAsRenderTargetOrDepth(texture))
                         continue;
 
                     ResourceBarrierTransition(
-                        resource,
+                        texture,
                         tracking.IsUAV[slot] ? BarrierLayout.UnorderedAccess : BarrierLayout.ShaderResource);
                 }
             }
         }
 
-        private bool IsBoundAsAttachment(GraphicsResource resource)
+        private bool IsBoundAsRenderTargetOrDepth(Texture texture)
         {
-            if (resource is not Texture texture)
-                return false;
-
             var parent = texture.ParentTexture ?? texture;
 
             var depth = DepthStencilBuffer;

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

@@ -124,8 +124,8 @@ internal ResourceTracking RentTracking(int srvCount, int handleIncrementSize)
 
             trackingOffset++;
 
-            // Clearing also leaves an untouched slot empty, which is what a slot holding a constant
-            // buffer must look like to the transition pass.
+            // A slot the Descriptor Set never writes must read as empty, because a constant buffer
+            // occupies a slot without a resource the transition pass can act on.
             tracking.Clear();
 
             return tracking;

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

@@ -248,9 +248,6 @@ internal void Set(int bindingOffset, GraphicsResource resource, bool isUav)
             IsUAV[index] = isUav;
         }
 
-        /// <summary>
-        ///   Reports whether this instance has room for a Descriptor Set with the given slot count.
-        /// </summary>
         internal bool CanTrack(int srvCount) => Resources.Length >= srvCount;
 
         /// <summary>