diff --git a/.idea/editor.xml b/.idea/editor.xml
index 9e1bfff..25fcf2b 100644
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -2,6 +2,8 @@
 <project version="4">
   <component name="BackendCodeEditorSettings">
     <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/INDENT_PREPROCESSOR_DIRECTIVES/@EntryValue" value="Normal" type="string" />
+    <option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
+    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_LIMIT/@EntryValue" value="150" type="long" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppSmartPointerVsMakeFunction/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppFunctionalStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
@@ -241,8 +243,6 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=StringLiteralTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CommentTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=IdentifierTypo/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
-    <option name="/Default/CodeStyle/EditorConfig/EnableClangFormatSupport/@EntryValue" value="false" type="bool" />
-    <option name="/Default/CodeStyle/CodeFormatting/CppFormatting/WRAP_LIMIT/@EntryValue" value="150" type="long" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppSmartPointerVsMakeFunction/@EntryIndexRemoved" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexRemoved" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppFunctionalStyleCast/@EntryIndexRemoved" />
diff --git a/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj b/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
index 6ce33f6..f9e09f5 100644
--- a/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
+++ b/Coplt.Graphics.Core/Coplt.Graphics.Core.csproj
@@ -15,8 +15,8 @@
     <ItemGroup>
         <PackageReference Include="Coplt.Dropping" Version="0.6.0" />
         <PackageReference Include="Coplt.Mathematics" Version="0.10.0"/>
-        <PackageReference Include="Coplt.Union" Version="0.11.0" />
-        <PackageReference Include="Fody" Version="6.9.1">
+        <PackageReference Include="Coplt.Union" Version="0.13.2" />
+        <PackageReference Include="Fody" Version="6.9.2">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
diff --git a/Coplt.Graphics.Core/Core/CommandList.cs b/Coplt.Graphics.Core/Core/CommandList.cs
index f5b1c4f..2ca07ca 100644
--- a/Coplt.Graphics.Core/Core/CommandList.cs
+++ b/Coplt.Graphics.Core/Core/CommandList.cs
@@ -18,7 +18,7 @@ public enum DispatchType : byte
 /// <summary>
 /// 命令列表，不支持多线程访问
 /// </summary>
-public sealed unsafe class CommandList
+public sealed unsafe class CommandList : IQueueOwned
 {
     #region Struct
 
@@ -231,7 +231,7 @@ public readonly bool IsCompatible(in ScopedState other, bool legacy, out bool sa
                 same = Legacy == other.Legacy;
                 return Legacy.IsCompatible(other.Legacy);
             }
-            if (Layout != other.Layout) goto no;
+            if (!Layout.IsCompatible(other.Layout)) goto no;
             if (Access != other.Access)
             {
                 same = false;
@@ -256,8 +256,48 @@ public void Merge(in ScopedState other, bool legacy, bool same)
             if (!same)
             {
                 if (legacy) Legacy |= other.Legacy;
-                else Access |= other.Access;
+                else
+                {
+                    Layout = Layout.Merge(other.Layout, (Access & ResAccess.NoAccess) != 0);
+                    Access |= other.Access;
+                }
+            }
+        }
+    }
+
+    internal struct PipelineContext
+    {
+        public ShaderPipeline? CurrentPipeline;
+        public ShaderBinding? CurrentBinding;
+
+        public bool PipelineChanged;
+        public bool BindingChanged;
+
+        public bool SetPipeline(CommandList self, ShaderPipeline Pipeline)
+        {
+            if (CurrentPipeline == Pipeline) return false;
+            self.AddObject(CurrentPipeline = Pipeline);
+            PipelineChanged = true;
+            if (CurrentBinding != null)
+            {
+                if (Pipeline.Shader.Layout != CurrentBinding.Layout)
+                    CurrentBinding = null;
+            }
+            return true;
+        }
+
+        public bool SetBinding(CommandList self, ShaderBinding Binding)
+        {
+            if (CurrentBinding == Binding) return false;
+            Binding.AssertSameQueue(self.Queue);
+            if (CurrentPipeline != null)
+            {
+                if (CurrentPipeline.Shader.Layout != Binding.Layout)
+                    throw new ArgumentException("This binding is incompatible with the current pipeline");
             }
+            self.AddObject(CurrentBinding = Binding);
+            BindingChanged = true;
+            return true;
         }
     }
 
@@ -288,6 +328,8 @@ public void Merge(in ScopedState other, bool legacy, bool same)
     internal readonly Dictionary<FResourceRef, ScopedState> m_scoped_res_state = new();
     internal readonly HashSet<object> m_objects = new();
     internal GpuOutput? m_current_output;
+    internal uint m_grow_cbv_srv_uav_binding_capacity;
+    internal uint m_grow_sampler_binding_capacity;
     internal int m_debug_scope_count;
     internal int m_render_debug_scope_count;
     internal int m_compute_debug_scope_count;
@@ -343,6 +385,8 @@ internal void Reset()
         m_string16.Clear();
         m_resources.Clear();
         m_objects.Clear();
+        m_grow_cbv_srv_uav_binding_capacity = 0;
+        m_grow_sampler_binding_capacity = 0;
         m_current_barrier_cmd_index = -1;
         m_auto_barrier = true;
         m_current_output = null;
@@ -400,6 +444,8 @@ internal void BuildSubmitStruct(GpuExecutor Executor, bool NoWait)
                 Str16 = p_string16,
                 CommandCount = (uint)m_commands.Count,
                 ResourceCount = (uint)m_resource_metas.Count,
+                GrowCbvSrvUavBindingCapacity = m_grow_cbv_srv_uav_binding_capacity,
+                GrowSamplerBindingCapacity = m_grow_sampler_binding_capacity,
             };
             Queue.ActualSubmit(Executor, &submit, NoWait);
         }
@@ -434,14 +480,14 @@ internal ref ScopedState RecordScopedResState(FResourceRef res, ScopedState stat
     }
 
     internal ArgumentException Incompatible(
-        string Name, in ScopedState old_state, LegacyState Legacy, ResAccess Access
+        string Name, in ScopedState old_state, LegacyState Legacy, ResAccess Access, ResLayout Layout
     ) =>
         UseLegacyState
             ? new ArgumentException(
                 $"{Name} cannot be in [{Legacy}] and [{old_state.Legacy}] states at the same time"
             )
             : new ArgumentException(
-                $"{Name} cannot be in [{Access}] and [{old_state.Access}] states at the same time"
+                $"{Name} cannot be in [{Access};{Layout}] and [{old_state.Access};{old_state.Layout}] states at the same time"
             );
 
     #endregion
@@ -709,6 +755,7 @@ public void ClearColor(IRtv Image, ReadOnlySpan<URect> Rects = default) =>
     /// </summary>
     public void ClearColor(IRtv Image, float4 Color, ReadOnlySpan<URect> Rects = default)
     {
+        Image.AssertSameQueue(Queue);
         if (!Image.TryRtv()) throw new ArgumentException($"Resource {Image} cannot be used as Rtv");
 
         var cmd = new FCommandClearColor
@@ -773,6 +820,7 @@ public void ClearDepthStencil(
         ReadOnlySpan<URect> Rects = default
     )
     {
+        Image.AssertSameQueue(Queue);
         if (!Image.TryDsv()) throw new ArgumentException($"Resource {Image} cannot be used as Dsv");
 
         var cmd = new FCommandClearDepthStencil
@@ -811,6 +859,8 @@ public void Bind(
         ShaderBinding Binding, ReadOnlySpan<ShaderBindingSetItem> Items
     )
     {
+        Binding.AssertSameQueue(Queue);
+        if (Items.Length == 0) return;
         AddObject(Binding);
         var cmd = new FCommandBind
         {
@@ -819,27 +869,11 @@ public void Bind(
             ItemCount = (uint)Items.Length,
             ItemsIndex = 0
         };
-        if (Items.Length > 0)
-        {
-            var index = m_bind_items.Count;
-            cmd.ItemsIndex = (uint)index;
-            CollectionsMarshal.SetCount(m_bind_items, m_bind_items.Count + Items.Length);
-            var dst = CollectionsMarshal.AsSpan(m_bind_items).Slice(index, Items.Length);
-            var defines = Binding.Layout.NativeDefines;
-            var views = Binding.MutViews;
-            for (var i = 0; i < Items.Length; i++)
-            {
-                var src = Items[i];
-                ref readonly var define = ref defines[(int)src.Index];
-                define.CheckCompatible(src.View, (int)src.Index);
-                dst[i] = new()
-                {
-                    Index = src.Index,
-                    View = src.View.ToFFI(),
-                };
-                views[(int)src.Index] = src.View;
-            }
-        }
+        var index = m_bind_items.Count;
+        cmd.ItemsIndex = (uint)index;
+        CollectionsMarshal.SetCount(m_bind_items, m_bind_items.Count + Items.Length);
+        var dst = CollectionsMarshal.AsSpan(m_bind_items).Slice(index, Items.Length);
+        Binding.Set(Items, dst);
         m_commands.Add(new() { Bind = cmd });
     }
 
@@ -855,6 +889,8 @@ public void Copy(
         ulong Size = ulong.MaxValue
     )
     {
+        Dst.AssertSameQueue(Queue);
+        Src.AssertSameQueue(Queue);
         if (Size != ulong.MaxValue)
         {
             if (DstOffset + Size > Dst.Size) throw new ArgumentException("The copy range exceeds the buffer range");
@@ -960,6 +996,7 @@ public void Upload(
         ulong DstOffset = 0
     )
     {
+        Dst.AssertSameQueue(Queue);
         if (Loc.SubmitId != m_queue.SubmitId)
             throw new ArgumentException("An attempt was made to use an expired upload location");
         var Size = Math.Min(Dst.Size, Loc.Size);
@@ -1044,6 +1081,7 @@ public RenderScope Render(
 
         var has_dsv = Info.Dsv.HasValue;
         var dsv = Info.Dsv ?? default;
+        if (has_dsv) dsv.View!.AssertSameQueue(Queue);
 
         #endregion
 
@@ -1114,6 +1152,7 @@ public RenderScope Render(
         for (var i = 0; i < Info.Rtvs.Length; i++)
         {
             ref readonly var rtv = ref Info.Rtvs[i];
+            rtv.View.AssertSameQueue(Queue);
             if (!rtv.View.Size2d.Equals(rt_size))
                 throw new ArgumentException("RenderTargets And DepthStencil must be the same size");
             info.Rtv[i] = AddResource(rtv.View.Resource);
@@ -1163,31 +1202,40 @@ public RenderScope Render(
 
         #region State
 
-        if (has_dsv)
+        if (AutoBarrierEnabled)
         {
-            ref var old_state = ref RecordScopedResState(
-                info.Dsv, new(
-                    ScopedStateUsage.Pixel,
-                    ResLayout.DepthStencilWrite,
-                    ResAccess.DepthStencilWrite,
-                    LegacyState.DepthWrite
-                ), out var compatible
-            );
-            if (!compatible)
-                throw Incompatible("Depth Stencil", old_state, LegacyState.DepthWrite, ResAccess.DepthStencilWrite);
-        }
-        for (var i = 0; i < info.NumRtv; i++)
-        {
-            ref var old_state = ref RecordScopedResState(
-                info.Rtv[i], new(
-                    ScopedStateUsage.Pixel,
-                    ResLayout.RenderTarget,
-                    ResAccess.RenderTarget,
-                    LegacyState.RenderTarget
-                ), out var compatible
-            );
-            if (!compatible)
-                throw Incompatible("Render Target", old_state, LegacyState.RenderTarget, ResAccess.RenderTarget);
+            if (has_dsv)
+            {
+                ref var old_state = ref RecordScopedResState(
+                    info.Dsv, new(
+                        ScopedStateUsage.Pixel,
+                        ResLayout.DepthStencilWrite,
+                        ResAccess.DepthStencilWrite,
+                        LegacyState.DepthWrite
+                    ), out var compatible
+                );
+                if (!compatible)
+                    throw Incompatible(
+                        "Depth Stencil", old_state, LegacyState.DepthWrite,
+                        ResAccess.DepthStencilWrite, ResLayout.DepthStencilWrite
+                    );
+            }
+            for (var i = 0; i < info.NumRtv; i++)
+            {
+                ref var old_state = ref RecordScopedResState(
+                    info.Rtv[i], new(
+                        ScopedStateUsage.Pixel,
+                        ResLayout.RenderTarget,
+                        ResAccess.RenderTarget,
+                        LegacyState.RenderTarget
+                    ), out var compatible
+                );
+                if (!compatible)
+                    throw Incompatible(
+                        "Render Target", old_state, LegacyState.RenderTarget,
+                        ResAccess.RenderTarget, ResLayout.RenderTarget
+                    );
+            }
         }
 
         #endregion
@@ -1261,6 +1309,99 @@ public ComputeScope Compute(string? Name = null, ReadOnlySpan<byte> Name8 = defa
     #endregion
 
     #endregion
+
+    #region SyncBinding
+
+    /// <summary>
+    /// 必须在 Render 或者 Compute 范围内使用
+    /// </summary>
+    internal void SyncBinding(ref PipelineContext context)
+    {
+        var binding = context.CurrentBinding;
+        if (binding == null) return;
+        if (AutoBarrierEnabled)
+        {
+            for (var i = 0; i < binding.Views.Length; i++)
+            {
+                ref readonly var def = ref binding.Layout.NativeDefines[i];
+                if (def.View is FShaderLayoutItemView.Sampler) continue;
+                ref readonly var view = ref binding.Views[i];
+                if (view.Tag is View.Tags.None) continue;
+                var is_buffer = false;
+                FResourceRef res;
+                switch (view.Tag)
+                {
+                case View.Tags.Buffer:
+                    res = AddResource(view.Buffer);
+                    is_buffer = true;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+                }
+                var Usage = def.Stage switch
+                {
+                    FShaderStage.Compute => ScopedStateUsage.Compute,
+                    FShaderStage.Pixel   => ScopedStateUsage.Pixel,
+                    FShaderStage.Vertex  => ScopedStateUsage.Vertex,
+                    FShaderStage.Mesh    => ScopedStateUsage.Mesh,
+                    FShaderStage.Task    => ScopedStateUsage.Mesh,
+                    _                    => throw new ArgumentOutOfRangeException()
+                };
+                var Layout = ResLayout.None;
+                ResAccess Access;
+                LegacyState Legacy;
+                switch (def.View)
+                {
+                case FShaderLayoutItemView.Cbv:
+                case FShaderLayoutItemView.Constants:
+                    Access = ResAccess.ConstantBuffer;
+                    Legacy = LegacyState.ConstantBuffer;
+                    break;
+                case FShaderLayoutItemView.Srv:
+                    if (!is_buffer) Layout = ResLayout.ShaderResource;
+                    Access = ResAccess.ShaderResource;
+                    Legacy = LegacyState.ShaderResource;
+                    break;
+                case FShaderLayoutItemView.Uav:
+                    if (!is_buffer) Layout = ResLayout.UnorderedAccess;
+                    Access = ResAccess.UnorderedAccess;
+                    Legacy = LegacyState.UnorderedAccess;
+                    break;
+                case FShaderLayoutItemView.Sampler:
+                default:
+                    throw new ArgumentOutOfRangeException();
+                }
+                ref var old_state = ref RecordScopedResState(
+                    res, new()
+                    {
+                        Usage = Usage,
+                        Layout = Layout,
+                        Access = Access,
+                        Legacy = Legacy
+                    }, out var compatible
+                );
+                if (!compatible)
+                    throw Incompatible($"{context.CurrentBinding}::[{i}]", old_state, Legacy, Access, Layout);
+            }
+        }
+        if (!(context.PipelineChanged || context.BindingChanged)) return;
+        context.PipelineChanged = false;
+        context.BindingChanged = false;
+        if (binding.Changed)
+        {
+            var layout = binding.Layout;
+            foreach (var (c, g) in binding.m_changed_groups)
+            {
+                ref readonly var @class = ref layout.NativeGroupClasses[(int)c];
+                ref readonly var group = ref @class.InfoSpan[(int)g];
+                if (group.View is FShaderLayoutGroupView.Sampler) m_grow_sampler_binding_capacity += group.Size;
+                else m_grow_cbv_srv_uav_binding_capacity += group.Size;
+            }
+            binding.ApplyChange();
+        }
+    }
+
+    #endregion
 }
 
 #region DebugScope
@@ -1435,8 +1576,7 @@ bool debug_scope
     #region Fields
 
     internal FCommandRender render_cmd = render_cmd;
-    internal ShaderPipeline? m_current_pipeline;
-    internal ShaderBinding? m_current_binding;
+    internal PipelineContext m_context;
     internal bool m_disposed;
     internal bool m_has_pixel_shader;
     internal bool m_has_vertex_shader;
@@ -1573,13 +1713,9 @@ public RenderDebugScope Scope(ReadOnlySpan<byte> Name)
 
     public void SetPipeline(ShaderPipeline Pipeline)
     {
-        if (m_current_pipeline == Pipeline) return;
-        self.AddObject(m_current_pipeline = Pipeline);
-        if (m_current_binding != null)
-        {
-            if (Pipeline.Shader.Layout != m_current_binding.Layout)
-                m_current_binding = null;
-        }
+        if (!Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Pixel))
+            throw new ArgumentException("Only shaders with a pixel stage can be used for rendering");
+        if (!m_context.SetPipeline(self, Pipeline)) return;
         var cmd = new FCommandSetPipeline
         {
             Base = { Type = FCommandType.SetPipeline },
@@ -1594,19 +1730,27 @@ public void SetPipeline(ShaderPipeline Pipeline)
 
     public void SetBinding(ShaderBinding Binding)
     {
-        if (m_current_binding == Binding) return;
-        if (m_current_pipeline != null)
-        {
-            if (m_current_pipeline.Shader.Layout != Binding.Layout)
-                throw new ArgumentException("This binding is incompatible with the current pipeline");
-        }
-        self.AddObject(m_current_binding = Binding);
+        if (!m_context.SetBinding(self, Binding)) return;
         var cmd = new FCommandSetBinding
         {
             Base = { Type = FCommandType.SetBinding },
             Binding = Binding.m_ptr,
         };
         m_commands.Add(new() { SetBinding = cmd });
+        if (!m_has_uav_writes)
+        {
+            for (var i = 0; i < Binding.Views.Length; i++)
+            {
+                ref readonly var view = ref Binding.Views[i];
+                if (view.Tag is View.Tags.None) continue;
+                ref readonly var def = ref Binding.Layout.NativeDefines[i];
+                if (def.View is FShaderLayoutItemView.Uav)
+                {
+                    m_has_uav_writes = true;
+                    break;
+                }
+            }
+        }
     }
 
     #endregion
@@ -1681,13 +1825,19 @@ ReadOnlySpan<VertexBufferRange> VertexBuffers
                 Offset = index_buffer.Offset,
                 Size = index_buffer.Size == uint.MaxValue ? (uint)index_buffer.Buffer.Size : index_buffer.Size,
             };
-            ref var old_state = ref self.RecordScopedResState(
-                buf.IndexBuffer.Buffer, new(
-                    ScopedStateUsage.Vertex, ResLayout.None, ResAccess.IndexBuffer, LegacyState.IndexBuffer
-                ), out var compatible
-            );
-            if (!compatible)
-                throw self.Incompatible("Index buffer", old_state, LegacyState.IndexBuffer, ResAccess.IndexBuffer);
+            if (self.AutoBarrierEnabled)
+            {
+                ref var old_state = ref self.RecordScopedResState(
+                    buf.IndexBuffer.Buffer, new(
+                        ScopedStateUsage.Vertex, ResLayout.None, ResAccess.IndexBuffer, LegacyState.IndexBuffer
+                    ), out var compatible
+                );
+                if (!compatible)
+                    throw self.Incompatible(
+                        "Index buffer", old_state, LegacyState.IndexBuffer,
+                        ResAccess.IndexBuffer, ResLayout.None
+                    );
+            }
         }
         if (VertexBuffers.Length > 0)
         {
@@ -1700,6 +1850,7 @@ ReadOnlySpan<VertexBufferRange> VertexBuffers
             for (var i = 0; i < VertexBuffers.Length; i++)
             {
                 var buffer = VertexBuffers[i];
+                buffer.Buffer.AssertSameQueue(self.Queue);
                 ref var dst = ref vbs[i];
                 dst = new()
                 {
@@ -1711,15 +1862,19 @@ ReadOnlySpan<VertexBufferRange> VertexBuffers
                     },
                     Index = buffer.Index,
                 };
-                ref var old_state = ref self.RecordScopedResState(
-                    dst.Base.Buffer, new(
-                        ScopedStateUsage.Vertex, ResLayout.None, ResAccess.VertexBuffer, LegacyState.VertexBuffer
-                    ), out var compatible
-                );
-                if (!compatible)
-                    throw self.Incompatible(
-                        "Vertex buffer", old_state, LegacyState.VertexBuffer, ResAccess.IndexBuffer
+                if (self.AutoBarrierEnabled)
+                {
+                    ref var old_state = ref self.RecordScopedResState(
+                        dst.Base.Buffer, new(
+                            ScopedStateUsage.Vertex, ResLayout.None, ResAccess.VertexBuffer, LegacyState.VertexBuffer
+                        ), out var compatible
                     );
+                    if (!compatible)
+                        throw self.Incompatible(
+                            "Vertex buffer", old_state, LegacyState.VertexBuffer,
+                            ResAccess.IndexBuffer, ResLayout.None
+                        );
+                }
             }
         }
         self.m_mesh_buffers.Add(buf);
@@ -1771,11 +1926,12 @@ public void Draw(
         }
         else
         {
-            if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
-            if (!m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Vertex))
-                throw new ArgumentException("Only Vertex shaders can use Draw");
+            if (m_context.CurrentPipeline == null) throw new InvalidOperationException("Pipeline is not set");
+            if (!m_context.CurrentPipeline.Shader.Stages.HasFlags(ShaderStageFlags.Vertex))
+                throw new ArgumentException("Only shaders with a vertex stage can use Draw");
         }
         if (Binding != null) SetBinding(Binding);
+        self.SyncBinding(ref m_context);
         var cmd = new FCommandDraw
         {
             Base = { Type = FCommandType.Draw },
@@ -1796,12 +1952,14 @@ public void Draw(
     #region DispatchMesh
 
     public void DispatchMesh(
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
-    ) => DispatchMesh(null, GroupCountX, GroupCountY, GroupCountZ);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
+    ) => DispatchMesh(null, GroupCountX, GroupCountY, GroupCountZ, Binding);
 
     public void DispatchMesh(
         ShaderPipeline? Pipeline,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
     )
     {
         if (Pipeline != null)
@@ -1812,10 +1970,12 @@ public void DispatchMesh(
         }
         else
         {
-            if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
-            if (!m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
-                throw new ArgumentException("Only Mesh shaders can use DispatchMesh");
+            if (m_context.CurrentPipeline == null) throw new InvalidOperationException("Pipeline is not set");
+            if (!m_context.CurrentPipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+                throw new ArgumentException("Only shaders with a mesh stage can use DispatchMesh");
         }
+        if (Binding != null) SetBinding(Binding);
+        self.SyncBinding(ref m_context);
         var cmd = new FCommandDispatch
         {
             Base = { Type = FCommandType.Draw },
@@ -1827,7 +1987,7 @@ public void DispatchMesh(
         m_commands.Add(new() { Dispatch = cmd });
         m_has_pixel_shader = true;
         m_has_mesh_shader = true;
-        m_has_task_shader = m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Task);
+        m_has_task_shader = m_context.CurrentPipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Task);
     }
 
     #endregion
@@ -1848,8 +2008,7 @@ bool debug_scope
     #region Fields
 
     internal FCommandCompute compute_cmd = compute_cmd;
-    internal ShaderPipeline? m_current_pipeline;
-    internal ShaderBinding? m_current_binding;
+    internal PipelineContext m_context;
     internal bool m_disposed;
     internal bool m_has_compute_shader;
     internal bool m_has_mesh_shader;
@@ -1980,13 +2139,11 @@ public ComputeDebugScope Scope(ReadOnlySpan<byte> Name)
 
     public void SetPipeline(ShaderPipeline Pipeline)
     {
-        if (m_current_pipeline == Pipeline) return;
-        self.AddObject(m_current_pipeline = Pipeline);
-        if (m_current_binding != null)
-        {
-            if (Pipeline.Shader.Layout != m_current_binding.Layout)
-                m_current_binding = null;
-        }
+        if (!Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
+            throw new ArgumentException("Only shaders with a Compute or Mesh stage can be used for computation");
+        if (Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Pixel))
+            throw new ArgumentException("Shaders with a pixel stage cannot be used for computation");
+        if (!m_context.SetPipeline(self, Pipeline)) return;
         var cmd = new FCommandSetPipeline
         {
             Base = { Type = FCommandType.SetPipeline },
@@ -2001,13 +2158,7 @@ public void SetPipeline(ShaderPipeline Pipeline)
 
     public void SetBinding(ShaderBinding Binding)
     {
-        if (m_current_binding == Binding) return;
-        if (m_current_pipeline != null)
-        {
-            if (m_current_pipeline.Shader.Layout != Binding.Layout)
-                throw new ArgumentException("This binding is incompatible with the current pipeline");
-        }
-        self.AddObject(m_current_binding = Binding);
+        if (!m_context.SetBinding(self, Binding)) return;
         var cmd = new FCommandSetBinding
         {
             Base = { Type = FCommandType.SetBinding },
@@ -2021,56 +2172,73 @@ public void SetBinding(ShaderBinding Binding)
     #region Dispatch
 
     public void Dispatch(
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
-    ) => Dispatch(null, DispatchType.Compute, GroupCountX, GroupCountY, GroupCountZ);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
+    ) => Dispatch(null, DispatchType.Compute, GroupCountX, GroupCountY, GroupCountZ, Binding);
 
     public void DispatchMesh(
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
-    ) => Dispatch(null, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
+    ) => Dispatch(null, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ, Binding);
 
     public void Dispatch(
         ShaderPipeline Pipeline,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
-    ) => Dispatch(Pipeline, DispatchType.Auto, GroupCountX, GroupCountY, GroupCountZ);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
+    ) => Dispatch(Pipeline, DispatchType.Auto, GroupCountX, GroupCountY, GroupCountZ, Binding);
 
     public void DispatchMesh(
         ShaderPipeline Pipeline,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
-    ) => Dispatch(Pipeline, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ);
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
+    ) => Dispatch(Pipeline, DispatchType.Mesh, GroupCountX, GroupCountY, GroupCountZ, Binding);
 
     public void Dispatch(
         ShaderPipeline? Pipeline, DispatchType Type,
-        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1
+        uint GroupCountX = 1, uint GroupCountY = 1, uint GroupCountZ = 1,
+        ShaderBinding? Binding = null
     )
     {
         if (Pipeline != null)
         {
-            if (!Pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
-                throw new ArgumentException("Only Mesh and Compute shaders can use Dispatch/DispatchMesh");
             SetPipeline(Pipeline);
         }
         else
         {
-            if (m_current_pipeline == null) throw new InvalidOperationException("Pipeline is not set");
-            if (!m_current_pipeline.Shader.Stages.HasAnyFlags(ShaderStageFlags.Compute | ShaderStageFlags.Mesh))
-                throw new ArgumentException("Only Mesh and Compute shaders can use Dispatch/DispatchMesh");
+            if (m_context.CurrentPipeline == null) throw new InvalidOperationException("Pipeline is not set");
         }
+        if (Binding != null) SetBinding(Binding);
         if (Type == DispatchType.Auto)
         {
-            if (m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute)) Type = DispatchType.Compute;
-            else if (m_current_pipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh)) Type = DispatchType.Mesh;
-            else throw new UnreachableException();
+            if (m_context.CurrentPipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute))
+            {
+                Type = DispatchType.Compute;
+                m_has_compute_shader = true;
+            }
+            else if (m_context.CurrentPipeline.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+            {
+                Type = DispatchType.Mesh;
+                m_has_mesh_shader = true;
+                if (m_context.CurrentPipeline.Shader.Stages.HasFlags(ShaderStageFlags.Task))
+                    m_has_task_shader = true;
+            }
+            else throw new ArgumentException("Only Mesh and Compute shaders can use in Compute Scope");
         }
         else if (Type == DispatchType.Mesh)
         {
-            if (!m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
+            if (!m_context.CurrentPipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Mesh))
                 throw new ArgumentException("Only Mesh shaders can use DispatchMesh");
+            m_has_mesh_shader = true;
+            if (m_context.CurrentPipeline.Shader.Stages.HasFlags(ShaderStageFlags.Task))
+                m_has_task_shader = true;
         }
         else if (Type == DispatchType.Compute)
         {
-            if (!m_current_pipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute))
+            if (!m_context.CurrentPipeline!.Shader.Stages.HasFlags(ShaderStageFlags.Compute))
                 throw new ArgumentException("Only Compute shaders can use Dispatch");
+            m_has_compute_shader = true;
         }
+        self.SyncBinding(ref m_context);
         var cmd = new FCommandDispatch
         {
             Base = { Type = FCommandType.SetBinding },
diff --git a/Coplt.Graphics.Core/Core/GpuOutput.cs b/Coplt.Graphics.Core/Core/GpuOutput.cs
index a874812..42d6286 100644
--- a/Coplt.Graphics.Core/Core/GpuOutput.cs
+++ b/Coplt.Graphics.Core/Core/GpuOutput.cs
@@ -64,7 +64,7 @@ public record struct GpuOutputOptions()
 #endregion
 
 [Dropping(Unmanaged = true)]
-public sealed unsafe partial class GpuOutput : GpuExecutor, IGpuResource, IRtv, ISrv
+public sealed unsafe partial class GpuOutput : GpuExecutor, IQueueOwned, IGpuResource, IRtv, ISrv
 {
     #region Fields
 
diff --git a/Coplt.Graphics.Core/Core/GpuQueue.cs b/Coplt.Graphics.Core/Core/GpuQueue.cs
index fd5564c..1960e91 100644
--- a/Coplt.Graphics.Core/Core/GpuQueue.cs
+++ b/Coplt.Graphics.Core/Core/GpuQueue.cs
@@ -226,33 +226,42 @@ public GpuBuffer CreateBuffer(
 
     #region WriteToUpload
 
-    public UploadLoc WriteToUpload(ReadOnlySpan<byte> Data)
+    /// <summary>
+    /// 返回的 Span 只能写入
+    /// </summary>
+    public Span<byte> AllocUploadMemory(uint Size, out UploadLoc loc)
     {
         using var _ = m_lock.EnterScope();
         ref var upload_buffers = ref m_ptr->m_context->m_upload_buffer;
         for (nuint i = 0; i < upload_buffers.LongLength; i++)
         {
             ref var block = ref upload_buffers[i];
-            if (block.cur_offset + (uint)Data.Length < block.size)
+            if (block.cur_offset + Size < block.size)
             {
-                Data.CopyTo(new Span<byte>(block.mapped_ptr, (int)block.size)[(int)block.cur_offset..]);
-                var loc = new UploadLoc(i, block.cur_offset, (uint)Data.Length, SubmitId);
-                block.cur_offset += (uint)Data.Length;
-                return loc;
+                var r = new Span<byte>(block.mapped_ptr, (int)block.size)[(int)block.cur_offset..];
+                loc = new UploadLoc(i, block.cur_offset, Size, SubmitId);
+                block.cur_offset += Size;
+                return r;
             }
         }
-        m_ptr->m_context->GrowUploadBuffer((uint)Data.Length).TryThrow();
+        m_ptr->m_context->GrowUploadBuffer(Size).TryThrow();
         upload_buffers = ref m_ptr->m_context->m_upload_buffer;
         {
             var i = upload_buffers.LongLength - 1;
             ref var block = ref upload_buffers[i];
-            if (block.cur_offset + (uint)Data.Length >= block.size) throw new OutOfMemoryException();
-            Data.CopyTo(new Span<byte>(block.mapped_ptr, (int)block.size)[(int)block.cur_offset..]);
-            var loc = new UploadLoc(i, block.cur_offset, (uint)Data.Length, SubmitId);
-            block.cur_offset += (uint)Data.Length;
-            return loc;
+            if (block.cur_offset + Size >= block.size) throw new OutOfMemoryException();
+            var r = new Span<byte>(block.mapped_ptr, (int)block.size)[(int)block.cur_offset..];
+            loc = new UploadLoc(i, block.cur_offset, Size, SubmitId);
+            block.cur_offset += Size;
+            return r;
         }
     }
 
+    public UploadLoc WriteToUpload(ReadOnlySpan<byte> Data)
+    {
+        Data.CopyTo(AllocUploadMemory((uint)Data.Length, out var loc));
+        return loc;
+    }
+
     #endregion
 }
diff --git a/Coplt.Graphics.Core/Core/GpuView.cs b/Coplt.Graphics.Core/Core/GpuView.cs
index 54c0625..86518d9 100644
--- a/Coplt.Graphics.Core/Core/GpuView.cs
+++ b/Coplt.Graphics.Core/Core/GpuView.cs
@@ -5,7 +5,7 @@
 namespace Coplt.Graphics.Core;
 
 [Dropping(Unmanaged = true)]
-public abstract unsafe partial class GpuView
+public abstract unsafe partial class GpuView : IQueueOwned
 {
     #region Fields
 
diff --git a/Coplt.Graphics.Core/Core/IQueueOwned.cs b/Coplt.Graphics.Core/Core/IQueueOwned.cs
new file mode 100644
index 0000000..f61c25a
--- /dev/null
+++ b/Coplt.Graphics.Core/Core/IQueueOwned.cs
@@ -0,0 +1,17 @@
+namespace Coplt.Graphics.Core;
+
+public interface IQueueOwned
+{
+    public GpuQueue Queue { get; }
+}
+
+public static partial class GraphicsExtensions
+{
+    public static bool IsSameQueue<T>(this T obj, GpuQueue queue) where T : IQueueOwned => obj.Queue == queue;
+
+    public static void AssertSameQueue<T>(this T obj, GpuQueue queue) where T : IQueueOwned
+    {
+        if (obj.Queue != queue)
+            throw new InvalidOperationException($"{obj} does not belong to {queue}.");
+    }
+}
diff --git a/Coplt.Graphics.Core/Core/PipelineState.cs b/Coplt.Graphics.Core/Core/PipelineState.cs
index 44b5c64..cda844c 100644
--- a/Coplt.Graphics.Core/Core/PipelineState.cs
+++ b/Coplt.Graphics.Core/Core/PipelineState.cs
@@ -277,7 +277,7 @@ public ReadOnlySpan<GraphicsFormat> RoRtvFormats
     }
 }
 
-namespace Coplt.Graphics
+namespace Coplt.Graphics.Core
 {
     public static partial class GraphicsExtensions
     {
diff --git a/Coplt.Graphics.Core/Core/ResState.cs b/Coplt.Graphics.Core/Core/ResState.cs
index fa92068..e5cfd20 100644
--- a/Coplt.Graphics.Core/Core/ResState.cs
+++ b/Coplt.Graphics.Core/Core/ResState.cs
@@ -1,4 +1,5 @@
-using Coplt.Graphics.Native;
+using System.Diagnostics;
+using Coplt.Graphics.Native;
 
 namespace Coplt.Graphics.Core;
 
@@ -136,4 +137,26 @@ public static partial class GraphicsExtensions
         Legacy = value.Legacy.FromFFI(),
         CrossQueue = value.CrossQueue,
     };
+
+    public static bool IsReadOnly(this ResLayout self) =>
+        self is ResLayout.GenericRead or ResLayout.ShaderResource or ResLayout.CopySrc or
+            ResLayout.DepthStencilRead or ResLayout.ResolveSrc or ResLayout.ShadingRate or
+            ResLayout.VideoDecodeRead or ResLayout.VideoProcessRead or ResLayout.VideoEncodeRead;
+
+    public static bool IsCompatible(this ResLayout self, ResLayout other)
+    {
+        if (self == other) return true;
+        return self.IsReadOnly() && other.IsReadOnly();
+    }
+
+    public static ResLayout Merge(this ResLayout self, ResLayout other, bool strict)
+    {
+        if (self == other) return self;
+        if (self.IsReadOnly() && other.IsReadOnly())
+        {
+            if (strict) return other;
+            return ResLayout.GenericRead;
+        }
+        return self;
+    }
 }
diff --git a/Coplt.Graphics.Core/Core/ShaderBinding.cs b/Coplt.Graphics.Core/Core/ShaderBinding.cs
index db361ac..52890b2 100644
--- a/Coplt.Graphics.Core/Core/ShaderBinding.cs
+++ b/Coplt.Graphics.Core/Core/ShaderBinding.cs
@@ -7,7 +7,7 @@ namespace Coplt.Graphics.Core;
 public record struct ShaderBindingSetItem(uint Index, View View);
 
 [Dropping(Unmanaged = true)]
-public sealed unsafe partial class ShaderBinding
+public sealed unsafe partial class ShaderBinding : IQueueOwned
 {
     #region Fields
 
@@ -16,8 +16,9 @@ public sealed unsafe partial class ShaderBinding
     internal readonly GpuDevice m_device;
     internal readonly GpuQueue m_queue;
     internal readonly ShaderLayout m_layout;
-    internal readonly FRoSlice<FView> m_native_views;
     internal readonly View[] m_views;
+    internal readonly HashSet<uint> m_changed_items = new();
+    internal readonly HashSet<(uint c, uint g)> m_changed_groups = new();
 
     #endregion
 
@@ -27,10 +28,10 @@ public sealed unsafe partial class ShaderBinding
     public GpuDevice Device => m_device;
     public GpuQueue Queue => m_queue;
     public ShaderLayout Layout => m_layout;
-    public ReadOnlySpan<FView> NativeViews => m_native_views.Span;
     public ReadOnlySpan<View> Views => m_views;
     internal Span<View> MutViews => m_views;
     public ref readonly View this[int index] => ref m_views[index];
+    internal bool Changed => m_changed_items.Count != 0 || m_changed_groups.Count != 0;
 
     #endregion
 
@@ -44,13 +45,7 @@ internal ShaderBinding(FShaderBinding* ptr, string? name, GpuDevice device, GpuQ
         m_queue = queue;
         m_layout = layout;
 
-        {
-            uint size = 0;
-            var views = m_ptr->GetViews(&size);
-            m_native_views = new(views, size);
-        }
-
-        m_views = new View[m_native_views.Length];
+        m_views = new View[m_layout.m_native_defines.Length];
     }
 
     #endregion
@@ -98,4 +93,44 @@ m_name is null
             : $"0x{nameof(ShaderBinding)}({(nuint)m_ptr:X} \"{m_name}\")";
 
     #endregion
+
+    #region Set
+
+    internal void Set(ReadOnlySpan<ShaderBindingSetItem> Items, Span<FBindItem> dst)
+    {
+        var defines = Layout.NativeDefines;
+        var infos = Layout.NativeItemInfos;
+        var views = MutViews;
+        for (var i = 0; i < Items.Length; i++)
+        {
+            var src = Items[i];
+            ref readonly var define = ref defines[(int)src.Index];
+            ref readonly var info = ref infos[(int)src.Index];
+            define.CheckCompatible(src.View, (int)src.Index);
+            dst[i] = new()
+            {
+                View = src.View.ToFFI(),
+                Index = src.Index,
+            };
+            ref var view = ref views[(int)src.Index];
+            view = src.View;
+            m_changed_items.Add(src.Index);
+            if (info.Place is FShaderLayoutItemPlace.Grouped)
+            {
+                m_changed_groups.Add((info.Class, info.Group));
+            }
+        }
+    }
+
+    #endregion
+
+    #region ApplyChange
+
+    internal void ApplyChange()
+    {
+        m_changed_items.Clear();
+        m_changed_groups.Clear();
+    }
+
+    #endregion
 }
diff --git a/Coplt.Graphics.Core/Core/ShaderLayout.cs b/Coplt.Graphics.Core/Core/ShaderLayout.cs
index 844a2fb..42f23a6 100644
--- a/Coplt.Graphics.Core/Core/ShaderLayout.cs
+++ b/Coplt.Graphics.Core/Core/ShaderLayout.cs
@@ -22,6 +22,7 @@ public enum ShaderLayoutItemView : byte
 public enum ShaderLayoutItemType : byte
 {
     ConstantBuffer,
+    Buffer,
     RawBuffer,
     StructureBuffer,
     StructureBufferWithCounter,
@@ -103,6 +104,8 @@ public sealed unsafe partial class ShaderLayout
     internal FShaderLayout* m_ptr;
     internal string? m_name;
     internal readonly FRoSlice<FShaderLayoutItemDefine> m_native_defines;
+    internal readonly FRoSlice<FShaderLayoutItemInfo> m_native_item_infos;
+    internal readonly FRoSlice<FShaderLayoutGroupClass> m_native_group_classes;
 
     #endregion
 
@@ -110,6 +113,8 @@ public sealed unsafe partial class ShaderLayout
 
     public FShaderLayout* Ptr => m_ptr;
     public ReadOnlySpan<FShaderLayoutItemDefine> NativeDefines => m_native_defines.Span;
+    public ReadOnlySpan<FShaderLayoutItemInfo> NativeItemInfos => m_native_item_infos.Span;
+    public ReadOnlySpan<FShaderLayoutGroupClass> NativeGroupClasses => m_native_group_classes.Span;
 
     #endregion
 
@@ -121,9 +126,21 @@ internal ShaderLayout(FShaderLayout* ptr, string? name)
         m_name = name;
         if (m_ptr != null)
         {
-            uint count = 0;
-            var defines = m_ptr->GetItemDefines(&count);
-            m_native_defines = new(defines, count);
+            {
+                uint count = 0;
+                var defines = m_ptr->GetItemDefines(&count);
+                m_native_defines = new(defines, count);
+            }
+            {
+                uint count = 0;
+                var defines = m_ptr->GetItemInfos(&count);
+                m_native_item_infos = new(defines, count);
+            }
+            {
+                uint count = 0;
+                var defines = m_ptr->GetGroupClasses(&count);
+                m_native_group_classes = new(defines, count);
+            }
         }
     }
 
diff --git a/Coplt.Graphics.Core/Core/Views.cs b/Coplt.Graphics.Core/Core/Views.cs
index 152a424..fb6fcad 100644
--- a/Coplt.Graphics.Core/Core/Views.cs
+++ b/Coplt.Graphics.Core/Core/Views.cs
@@ -2,7 +2,7 @@
 
 namespace Coplt.Graphics.Core;
 
-public interface IGpuView
+public interface IGpuView : IQueueOwned
 {
     /// <summary>
     /// 视图所属资源
@@ -63,11 +63,6 @@ public enum GpuResourceType
 
 public interface IGpuResource : IGpuView
 {
-    /// <summary>
-    /// 资源所属队列
-    /// </summary>
-    public GpuQueue Queue { get; }
-    
     public GpuResourceType Type { get; }
 
     public ResState State { get; set; }
diff --git a/Coplt.Graphics.Core/Native/FShaderLayoutGroupClass.cs b/Coplt.Graphics.Core/Native/FShaderLayoutGroupClass.cs
new file mode 100644
index 0000000..8082b7c
--- /dev/null
+++ b/Coplt.Graphics.Core/Native/FShaderLayoutGroupClass.cs
@@ -0,0 +1,6 @@
+namespace Coplt.Graphics.Native;
+
+public unsafe partial struct FShaderLayoutGroupClass
+{
+    public ReadOnlySpan<FShaderLayoutGroupInfo> InfoSpan => new(Infos, (int)Size);
+}
diff --git a/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs b/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs
index 1ee5c88..2d4dfaa 100644
--- a/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs
+++ b/Coplt.Graphics.Core/Native/FShaderLayoutItemDefine.cs
@@ -1,4 +1,5 @@
-using Coplt.Graphics.Core;
+using System.Diagnostics;
+using Coplt.Graphics.Core;
 
 namespace Coplt.Graphics.Native;
 
@@ -9,15 +10,78 @@ public partial struct FShaderLayoutItemDefine
     /// </summary>
     public readonly void CheckCompatible(in View view, int index)
     {
+        if (View is FShaderLayoutItemView.Constants)
+            throw new ArgumentException(
+                $"Binding slot {index} required [{View}], [{View}] slot cannot bind resources."
+            );
         switch (view.Tag)
         {
         case Core.View.Tags.None:
             break;
         case Core.View.Tags.Buffer:
-            if (Type is not (FShaderLayoutItemType.ConstantBuffer or FShaderLayoutItemType.RawBuffer
-                or FShaderLayoutItemType.StructureBuffer or FShaderLayoutItemType.StructureBufferWithCounter))
-                throw new ArgumentException($"Binding slot {index} does not supports buffers");
+        {
+            var buffer = view.Buffer;
+            switch (Type)
+            {
+            case FShaderLayoutItemType.RayTracingAccelerationStructure:
+            case FShaderLayoutItemType.ConstantBuffer:
+            case FShaderLayoutItemType.RawBuffer:
+                if (buffer.Usage is not BufferUsage.Raw)
+                    throw new ArgumentException(
+                        $"Binding slot [{index}] required [{Type} (Usage: {BufferUsage.Raw})] but usage of [{buffer}] is a [{buffer.Usage}]."
+                    );
+                break;
+            case FShaderLayoutItemType.StructureBuffer:
+            case FShaderLayoutItemType.StructureBufferWithCounter:
+                if (buffer.Usage is not BufferUsage.Raw)
+                    throw new ArgumentException(
+                        $"Binding slot [{index}] required [{Type} (Usage: {BufferUsage.Structured})] but usage of [{buffer}] is a [{buffer.Usage}]."
+                    );
+                break;
+            case FShaderLayoutItemType.Texture1D:
+            case FShaderLayoutItemType.Texture1DArray:
+            case FShaderLayoutItemType.Texture2D:
+            case FShaderLayoutItemType.Texture2DArray:
+            case FShaderLayoutItemType.Texture2DMultisample:
+            case FShaderLayoutItemType.Texture2DArrayMultisample:
+            case FShaderLayoutItemType.Texture3D:
+            case FShaderLayoutItemType.TextureCube:
+            case FShaderLayoutItemType.TextureCubeArray:
+            case FShaderLayoutItemType.Sampler:
+                throw new ArgumentException(
+                    $"Binding slot [{index}] required [{Type}] but [{buffer}] is a {nameof(GpuBuffer)}."
+                );
+            default:
+                throw new ArgumentOutOfRangeException();
+            }
+            switch (View)
+            {
+            case FShaderLayoutItemView.Cbv:
+                if (!buffer.TryCbv())
+                    throw new ArgumentException(
+                        $"Binding slot [{index}] required [{View}], but [{buffer}] cannot be used as [{View}]."
+                    );
+                break;
+            case FShaderLayoutItemView.Srv:
+                if (!buffer.TrySrv())
+                    throw new ArgumentException(
+                        $"Binding slot [{index}] required [{View}], but [{buffer}] cannot be used as [{View}]."
+                    );
+                break;
+            case FShaderLayoutItemView.Uav:
+                if (!buffer.TryUav())
+                    throw new ArgumentException(
+                        $"Binding slot [{index}] required [{View}], but [{buffer}] cannot be used as [{View}]."
+                    );
+                break;
+            case FShaderLayoutItemView.Sampler:
+            case FShaderLayoutItemView.Constants:
+                throw new UnreachableException();
+            default:
+                throw new ArgumentOutOfRangeException();
+            }
             break;
+        }
         default:
             throw new ArgumentOutOfRangeException();
         }
diff --git a/Coplt.Graphics.Core/Native/Native.D3d12.cs b/Coplt.Graphics.Core/Native/Native.D3d12.cs
index cb1eed9..fa20400 100644
--- a/Coplt.Graphics.Core/Native/Native.D3d12.cs
+++ b/Coplt.Graphics.Core/Native/Native.D3d12.cs
@@ -326,10 +326,24 @@ public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
             return ((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, uint*, FShaderLayoutItemDefine*>)(lpVtbl[5]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this), out_count);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("const FShaderLayoutItemInfo *")]
+        public FShaderLayoutItemInfo* GetItemInfos([NativeTypeName("Coplt::u32 *")] uint* out_count)
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, uint*, FShaderLayoutItemInfo*>)(lpVtbl[6]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this), out_count);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("const FShaderLayoutGroupClass *")]
+        public FShaderLayoutGroupClass* GetGroupClasses([NativeTypeName("Coplt::u32 *")] uint* out_count)
+        {
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, uint*, FShaderLayoutGroupClass*>)(lpVtbl[7]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this), out_count);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void* GetRootSignaturePtr()
         {
-            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, void*>)(lpVtbl[6]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this));
+            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderLayout*, void*>)(lpVtbl[8]))((FD3d12ShaderLayout*)Unsafe.AsPointer(ref this));
         }
 
         public interface Interface : FShaderLayout.Interface
@@ -502,21 +516,6 @@ public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
             return *((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), &result, name);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FView *")]
-        public FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size)
-        {
-            return ((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, uint*, FView*>)(lpVtbl[5]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), out_size);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings)
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FD3d12ShaderBinding*, FResult*, uint, FShaderBindingBatchSet*, FResult*>)(lpVtbl[6]))((FD3d12ShaderBinding*)Unsafe.AsPointer(ref this), &result, count, bindings);
-        }
-
         public interface Interface : FShaderBinding.Interface
         {
         }
diff --git a/Coplt.Graphics.Core/Native/Native.cs b/Coplt.Graphics.Core/Native/Native.cs
index 7d550bf..bdf9838 100644
--- a/Coplt.Graphics.Core/Native/Native.cs
+++ b/Coplt.Graphics.Core/Native/Native.cs
@@ -1075,6 +1075,9 @@ public partial struct FDeviceFeatureRequires
 
         [NativeTypeName("Coplt::b8")]
         public B8 DynBindless;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DynBindlessOnly;
     }
 
     public partial struct FDeviceFeatures
@@ -1099,6 +1102,9 @@ public partial struct FDeviceFeatures
 
         [NativeTypeName("Coplt::b8")]
         public B8 DynBindless;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 DynBindlessOnly;
     }
 
     [NativeTypeName("Coplt::i32")]
@@ -1319,10 +1325,30 @@ public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
             return ((delegate* unmanaged[Thiscall]<FShaderLayout*, uint*, FShaderLayoutItemDefine*>)(lpVtbl[5]))((FShaderLayout*)Unsafe.AsPointer(ref this), out_count);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("const FShaderLayoutItemInfo *")]
+        public FShaderLayoutItemInfo* GetItemInfos([NativeTypeName("Coplt::u32 *")] uint* out_count)
+        {
+            return ((delegate* unmanaged[Thiscall]<FShaderLayout*, uint*, FShaderLayoutItemInfo*>)(lpVtbl[6]))((FShaderLayout*)Unsafe.AsPointer(ref this), out_count);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [return: NativeTypeName("const FShaderLayoutGroupClass *")]
+        public FShaderLayoutGroupClass* GetGroupClasses([NativeTypeName("Coplt::u32 *")] uint* out_count)
+        {
+            return ((delegate* unmanaged[Thiscall]<FShaderLayout*, uint*, FShaderLayoutGroupClass*>)(lpVtbl[7]))((FShaderLayout*)Unsafe.AsPointer(ref this), out_count);
+        }
+
         public interface Interface : FGpuObject.Interface
         {
             [return: NativeTypeName("const FShaderLayoutItemDefine *")]
             FShaderLayoutItemDefine* GetItemDefines([NativeTypeName("Coplt::u32 *")] uint* out_count);
+
+            [return: NativeTypeName("const FShaderLayoutItemInfo *")]
+            FShaderLayoutItemInfo* GetItemInfos([NativeTypeName("Coplt::u32 *")] uint* out_count);
+
+            [return: NativeTypeName("const FShaderLayoutGroupClass *")]
+            FShaderLayoutGroupClass* GetGroupClasses([NativeTypeName("Coplt::u32 *")] uint* out_count);
         }
     }
 
@@ -1534,7 +1560,7 @@ public unsafe partial struct FShaderBindingCreateOptions
         public FShaderLayout* Layout;
     }
 
-    public partial struct FShaderBindingBatchSet
+    public partial struct FBindItem
     {
         [NativeTypeName("Coplt::FView")]
         public FView View;
@@ -1585,28 +1611,8 @@ public FResult SetName([NativeTypeName("const FStr8or16 &")] FStr8or16* name)
             return *((delegate* unmanaged[Thiscall]<FShaderBinding*, FResult*, FStr8or16*, FResult*>)(lpVtbl[4]))((FShaderBinding*)Unsafe.AsPointer(ref this), &result, name);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FView *")]
-        public FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size)
-        {
-            return ((delegate* unmanaged[Thiscall]<FShaderBinding*, uint*, FView*>)(lpVtbl[5]))((FShaderBinding*)Unsafe.AsPointer(ref this), out_size);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [return: NativeTypeName("Coplt::FResult")]
-        public FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings)
-        {
-            FResult result;
-            return *((delegate* unmanaged[Thiscall]<FShaderBinding*, FResult*, uint, FShaderBindingBatchSet*, FResult*>)(lpVtbl[6]))((FShaderBinding*)Unsafe.AsPointer(ref this), &result, count, bindings);
-        }
-
         public interface Interface : FGpuObject.Interface
         {
-            [return: NativeTypeName("Coplt::FView *")]
-            FView* GetViews([NativeTypeName("Coplt::u32 *")] uint* out_size);
-
-            [return: NativeTypeName("Coplt::FResult")]
-            FResult Set([NativeTypeName("Coplt::u32")] uint count, [NativeTypeName("const FShaderBindingBatchSet *")] FShaderBindingBatchSet* bindings);
         }
     }
 
@@ -2365,6 +2371,12 @@ public unsafe partial struct FCommandSubmit
 
         [NativeTypeName("Coplt::u32")]
         public uint ResourceCount;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint GrowCbvSrvUavBindingCapacity;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint GrowSamplerBindingCapacity;
     }
 
     [Guid("F1C59CB4-7EE6-4EE2-80F4-07CC568920D2")]
@@ -2953,18 +2965,6 @@ public enum FDepthStencilClearFlags : byte
         Stencil = 2,
     }
 
-    public partial struct FBindItem
-    {
-        [NativeTypeName("Coplt::FCommandType")]
-        public FCommandType Type;
-
-        [NativeTypeName("Coplt::FView")]
-        public FView View;
-
-        [NativeTypeName("Coplt::u32")]
-        public uint Index;
-    }
-
     public partial struct FUploadLoc
     {
         [NativeTypeName("Coplt::u32")]
@@ -3058,6 +3058,15 @@ public partial struct FRenderInfo
         [NativeTypeName("u32[8]")]
         public _ResolveInfoIndex_e__FixedBuffer ResolveInfoIndex;
 
+        [NativeTypeName("Coplt::u32")]
+        public uint DsvResolveInfoIndex;
+
+        [NativeTypeName("FGraphicsFormat[8]")]
+        public _RtvFormat_e__FixedBuffer RtvFormat;
+
+        [NativeTypeName("Coplt::FGraphicsFormat")]
+        public FGraphicsFormat DsvFormat;
+
         [NativeTypeName("f32[32]")]
         public _Color_e__FixedBuffer Color;
 
@@ -3094,6 +3103,12 @@ public partial struct _ResolveInfoIndex_e__FixedBuffer
             public uint e0;
         }
 
+        [InlineArray(8)]
+        public partial struct _RtvFormat_e__FixedBuffer
+        {
+            public FGraphicsFormat e0;
+        }
+
         [InlineArray(32)]
         public partial struct _Color_e__FixedBuffer
         {
@@ -3468,7 +3483,7 @@ public partial struct FCommandDispatch
 
     public partial struct FCommandItem
     {
-        [NativeTypeName("__AnonymousRecord_Command_L489_C9")]
+        [NativeTypeName("__AnonymousRecord_Command_L485_C9")]
         public _Anonymous_e__Union Anonymous;
 
         [UnscopedRef]
@@ -3666,7 +3681,7 @@ public partial struct __pad_e__FixedBuffer
 
     public partial struct FRenderCommandItem
     {
-        [NativeTypeName("__AnonymousRecord_Command_L517_C9")]
+        [NativeTypeName("__AnonymousRecord_Command_L513_C9")]
         public _Anonymous_e__Union Anonymous;
 
         [UnscopedRef]
@@ -3836,7 +3851,7 @@ public partial struct __pad_e__FixedBuffer
 
     public partial struct FComputeCommandItem
     {
-        [NativeTypeName("__AnonymousRecord_Command_L540_C9")]
+        [NativeTypeName("__AnonymousRecord_Command_L536_C9")]
         public _Anonymous_e__Union Anonymous;
 
         [UnscopedRef]
@@ -3972,10 +3987,20 @@ public enum FShaderLayoutItemView : byte
         Constants,
     }
 
+    [NativeTypeName("Coplt::u8")]
+    public enum FShaderLayoutGroupView : byte
+    {
+        Cbv,
+        Srv,
+        Uav,
+        Sampler,
+    }
+
     [NativeTypeName("Coplt::u8")]
     public enum FShaderLayoutItemType : byte
     {
         ConstantBuffer,
+        Buffer,
         RawBuffer,
         StructureBuffer,
         StructureBufferWithCounter,
@@ -4027,6 +4052,58 @@ public partial struct FShaderLayoutItemDefine
         public FShaderLayoutItemUsage Usage;
     }
 
+    [NativeTypeName("Coplt::u8")]
+    public enum FShaderLayoutItemPlace : byte
+    {
+        None,
+        Const,
+        Direct,
+        Grouped,
+        StaticSampler,
+    }
+
+    public partial struct FShaderLayoutItemInfo
+    {
+        [NativeTypeName("Coplt::u32")]
+        public uint Index;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Class;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Group;
+
+        [NativeTypeName("Coplt::FShaderLayoutItemPlace")]
+        public FShaderLayoutItemPlace Place;
+    }
+
+    public partial struct FShaderLayoutGroupInfo
+    {
+        [NativeTypeName("Coplt::u32")]
+        public uint Index;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Size;
+
+        [NativeTypeName("Coplt::FShaderStage")]
+        public FShaderStage Stage;
+
+        [NativeTypeName("Coplt::FShaderLayoutGroupView")]
+        public FShaderLayoutGroupView View;
+    }
+
+    public unsafe partial struct FShaderLayoutGroupClass
+    {
+        [NativeTypeName("Coplt::FShaderLayoutGroupInfo *")]
+        public FShaderLayoutGroupInfo* Infos;
+
+        [NativeTypeName("Coplt::u32")]
+        public uint Size;
+
+        [NativeTypeName("Coplt::b8")]
+        public B8 Sampler;
+    }
+
     [NativeTypeName("Coplt::u8")]
     public enum FShaderLayoutFlags : byte
     {
diff --git a/Coplt.Graphics.Core/Native/ResState.cs b/Coplt.Graphics.Core/Native/ResState.cs
index 7e934d5..76e8bda 100644
--- a/Coplt.Graphics.Core/Native/ResState.cs
+++ b/Coplt.Graphics.Core/Native/ResState.cs
@@ -15,7 +15,7 @@ public readonly bool IsCompatible(in FResState other, bool legacy, /* 顺序 */
                 same = Legacy == other.Legacy;
                 return Legacy.FromFFI().IsCompatible(other.Legacy.FromFFI());
             }
-            if (Layout != other.Layout || CrossQueue != other.CrossQueue) goto no;
+            if (!Layout.FromFFI().IsCompatible(other.Layout.FromFFI()) || CrossQueue != other.CrossQueue) goto no;
             if (Access != other.Access)
             {
                 same = false;
@@ -68,6 +68,7 @@ public readonly FResState Merge(in FResState other, bool legacy, /* 顺序 */ bo
             var ona = (other.Access.FromFFI() & ResAccess.NoAccess) != 0;
             if (b2a)
             {
+                var Layout = this.Layout.FromFFI().Merge(other.Layout.FromFFI(), sna).ToFFI();
                 if (sna)
                     return new()
                     {
@@ -82,6 +83,7 @@ public readonly FResState Merge(in FResState other, bool legacy, /* 顺序 */ bo
             }
             else
             {
+                var Layout = this.Layout.FromFFI().Merge(other.Layout.FromFFI(), ona).ToFFI();
                 if (ona)
                     return new()
                     {
@@ -96,7 +98,7 @@ public readonly FResState Merge(in FResState other, bool legacy, /* 顺序 */ bo
             }
             return new()
             {
-                Layout = Layout,
+                Layout = this.Layout.FromFFI().Merge(other.Layout.FromFFI(), false).ToFFI(),
                 // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
                 Access = Access | other.Access,
                 // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
diff --git a/Coplt.Graphics.Native/Api/CMakeLists.txt b/Coplt.Graphics.Native/Api/CMakeLists.txt
index 05e894f..37f910b 100644
--- a/Coplt.Graphics.Native/Api/CMakeLists.txt
+++ b/Coplt.Graphics.Native/Api/CMakeLists.txt
@@ -48,6 +48,8 @@ add_library(${target_name} STATIC
     FFI/Features.h
     FFI/Adapter.h
     Include/ChunkedVector.h
+    Include/Ptr.h
+    Src/Error.cc
 )
 set_target_properties(${target_name} PROPERTIES LINKER_LANGUAGE CXX)
 add_library(Coplt::Graphics::Api ALIAS ${target_name})
diff --git a/Coplt.Graphics.Native/Api/FFI/Binding.h b/Coplt.Graphics.Native/Api/FFI/Binding.h
index d14b574..65e737f 100644
--- a/Coplt.Graphics.Native/Api/FFI/Binding.h
+++ b/Coplt.Graphics.Native/Api/FFI/Binding.h
@@ -12,7 +12,7 @@ namespace Coplt
         FShaderLayout* Layout{};
     };
 
-    struct FShaderBindingBatchSet
+    struct FBindItem
     {
         FView View{};
         u32 Index{};
@@ -20,8 +20,5 @@ namespace Coplt
 
     COPLT_INTERFACE_DEFINE(FShaderBinding, "a3ca644a-0e02-4d25-9a18-8835d66600f7", FGpuObject)
     {
-        virtual FView* GetViews(u32* out_size) noexcept = 0;
-
-        virtual FResult Set(u32 count, const FShaderBindingBatchSet* bindings) noexcept = 0;
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Command.h b/Coplt.Graphics.Native/Api/FFI/Command.h
index 854fd50..03e714a 100644
--- a/Coplt.Graphics.Native/Api/FFI/Command.h
+++ b/Coplt.Graphics.Native/Api/FFI/Command.h
@@ -196,13 +196,6 @@ namespace Coplt
         Stencil = 2,
     };
 
-    struct FBindItem
-    {
-        FCommandType Type{};
-        FView View{};
-        u32 Index{};
-    };
-
     struct FUploadLoc
     {
         u32 Index{};
@@ -579,6 +572,9 @@ namespace Coplt
         Char16* Str16{};
         u32 CommandCount{};
         u32 ResourceCount{};
+        // 需要增长多少绑定容量，仅在后端使用描述符堆时使用
+        u32 GrowCbvSrvUavBindingCapacity{};
+        u32 GrowSamplerBindingCapacity{};
     };
 
     ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/Coplt.Graphics.Native/Api/FFI/Features.h b/Coplt.Graphics.Native/Api/FFI/Features.h
index d0f3d54..836743d 100644
--- a/Coplt.Graphics.Native/Api/FFI/Features.h
+++ b/Coplt.Graphics.Native/Api/FFI/Features.h
@@ -36,6 +36,8 @@ namespace Coplt
         b8 ArrBindless{};
         // 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
         b8 DynBindless{};
+        // 仅动态无绑定模式，将无法使用着色器绑定，着色器布局中只能具有根常量/常量推送，此模式具有设备全局描述符堆
+        b8 DynBindlessOnly{};
     };
 
     struct FDeviceFeatures
@@ -54,5 +56,7 @@ namespace Coplt
         b8 ArrBindless{};
         // 真 · 无绑定, dx 使用 dynamic resource，vk 使用 VK_EXT_mutable_descriptor_type
         b8 DynBindless{};
+        // 仅动态无绑定模式，将无法使用着色器绑定，着色器布局中只能具有根常量/常量推送，此模式具有设备全局描述符堆
+        b8 DynBindlessOnly{};
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Layout.h b/Coplt.Graphics.Native/Api/FFI/Layout.h
index d278ca8..29b0ae8 100644
--- a/Coplt.Graphics.Native/Api/FFI/Layout.h
+++ b/Coplt.Graphics.Native/Api/FFI/Layout.h
@@ -20,9 +20,18 @@ namespace Coplt
         Constants,
     };
 
+    enum class FShaderLayoutGroupView : u8
+    {
+        Cbv,
+        Srv,
+        Uav,
+        Sampler,
+    };
+
     enum class FShaderLayoutItemType : u8
     {
         ConstantBuffer,
+        Buffer,
         RawBuffer,
         StructureBuffer,
         StructureBufferWithCounter,
@@ -39,6 +48,24 @@ namespace Coplt
         RayTracingAccelerationStructure,
     };
 
+    #ifdef FFI_SRC
+    inline bool IsBuffer(const FShaderLayoutItemType value)
+    {
+        switch (value)
+        {
+        case FShaderLayoutItemType::ConstantBuffer:
+        case FShaderLayoutItemType::Buffer:
+        case FShaderLayoutItemType::RawBuffer:
+        case FShaderLayoutItemType::StructureBuffer:
+        case FShaderLayoutItemType::StructureBufferWithCounter:
+        case FShaderLayoutItemType::RayTracingAccelerationStructure:
+            return true;
+        default: ;
+        }
+        return false;
+    }
+    #endif
+
     enum class FShaderLayoutItemUsage : u8
     {
         // 一般改变频率的变量，可能每帧都会改变
@@ -62,7 +89,7 @@ namespace Coplt
         FShaderLayoutItemType Type{};
         FShaderLayoutItemUsage Usage{};
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         bool IsAllowBuffer() const
         {
             switch (Type)
@@ -95,7 +122,52 @@ namespace Coplt
                 return false;
             }
         }
-#endif
+        #endif
+    };
+
+    enum class FShaderLayoutItemPlace : u8
+    {
+        None,
+        Const,
+        Direct,
+        Grouped,
+        StaticSampler,
+    };
+
+    struct FShaderLayoutItemInfo
+    {
+        // Const | Direct 时是 Root Index，Grouped 时是 Group 内的 Index
+        u32 Index{};
+        // 所属哪个绑定组类
+        u32 Class{};
+        // 所属哪个绑定组
+        u32 Group{};
+        // 绑定放在哪
+        FShaderLayoutItemPlace Place{};
+    };
+
+    struct FShaderLayoutGroupInfo
+    {
+        // Root Index
+        u32 Index{};
+        // 包含多少个绑定
+        u32 Size{};
+        FShaderStage Stage{};
+        FShaderLayoutGroupView View{};
+    };
+
+    struct FShaderLayoutGroupClass
+    {
+        FShaderLayoutGroupInfo* Infos{};
+        u32 Size{};
+        b8 Sampler{};
+
+        #if FFI_SRC
+        std::span<const FShaderLayoutGroupInfo> AsSpan() const noexcept
+        {
+            return std::span{Infos, static_cast<usize>(Size)};
+        }
+        #endif
     };
 
     COPLT_ENUM_FLAGS(FShaderLayoutFlags, u8)
@@ -129,14 +201,28 @@ namespace Coplt
         FShaderLayoutFlags Flags{};
 
         virtual const FShaderLayoutItemDefine* GetItemDefines(u32* out_count) noexcept = 0;
+        virtual const FShaderLayoutItemInfo* GetItemInfos(u32* out_count) noexcept = 0;
+        virtual const FShaderLayoutGroupClass* GetGroupClasses(u32* out_count) noexcept = 0;
 
-#if FFI_SRC
+        #if FFI_SRC
         std::span<const FShaderLayoutItemDefine> GetItemDefines() noexcept
         {
             u32 count{};
             return std::span{GetItemDefines(&count), static_cast<usize>(count)};
         }
-#endif
+
+        std::span<const FShaderLayoutItemInfo> GetItemInfos() noexcept
+        {
+            u32 count{};
+            return std::span{GetItemInfos(&count), static_cast<usize>(count)};
+        }
+
+        std::span<const FShaderLayoutGroupClass> GetGroupClasses() noexcept
+        {
+            u32 count{};
+            return std::span{GetGroupClasses(&count), static_cast<usize>(count)};
+        }
+        #endif
     };
 
     struct FShaderInputLayoutCreateOptions
@@ -150,13 +236,13 @@ namespace Coplt
     {
         virtual const FShaderInputLayoutElement* GetElements(u32* out_count) noexcept = 0;
 
-#if FFI_SRC
+        #if FFI_SRC
         std::span<const FShaderInputLayoutElement> GetElements() noexcept
         {
             u32 count{};
             return std::span{GetElements(&count), static_cast<usize>(count)};
         }
-#endif
+        #endif
     };
 
     struct FMeshLayoutCreateOptions
@@ -176,7 +262,7 @@ namespace Coplt
 
         virtual const FMeshBufferElement* TryGetElement(u32 SlotId, u32 SlotIndex) const noexcept = 0;
 
-#if FFI_SRC
+        #if FFI_SRC
         std::span<const FMeshBufferDefine> GetBuffers() const noexcept
         {
             u32 count{};
@@ -188,6 +274,6 @@ namespace Coplt
             u32 count{};
             return std::span{GetElements(&count), static_cast<usize>(count)};
         }
-#endif
+        #endif
     };
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/String.h b/Coplt.Graphics.Native/Api/FFI/String.h
index 637776d..1e4202f 100644
--- a/Coplt.Graphics.Native/Api/FFI/String.h
+++ b/Coplt.Graphics.Native/Api/FFI/String.h
@@ -72,6 +72,11 @@ namespace Coplt
         Str8,
     };
 
+    #ifdef FFI_SRC
+    struct FStr8or16;
+    extern FString* ToString(const FStr8or16& str);
+    #endif
+
     struct FStr8or16
     {
         union
@@ -83,7 +88,7 @@ namespace Coplt
         i32 len;
         FStrType type;
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         FStr8or16() = default;
 
         explicit FStr8or16(const char* ptr, const usize len)
@@ -113,7 +118,7 @@ namespace Coplt
         {
         }
 
-#ifdef _WINDOWS
+        #ifdef _WINDOWS
 
         explicit FStr8or16(const wchar_t* ptr, const usize len)
             : str16(reinterpret_cast<const Char16*>(ptr)),
@@ -134,7 +139,7 @@ namespace Coplt
         {
         }
 
-#endif
+        #endif
 
         bool is8() const
         {
@@ -151,8 +156,11 @@ namespace Coplt
             return str16 == nullptr;
         }
 
-        FString* ToString() const;
-#endif
+        FString* ToString() const
+        {
+            return Coplt::ToString(*this);
+        }
+        #endif
     };
 
     struct FCStr8or16
@@ -160,7 +168,7 @@ namespace Coplt
         const char* str8;
         const Char16* str16;
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         bool has8() const
         {
             return str8 != nullptr;
@@ -175,10 +183,10 @@ namespace Coplt
         {
             return str8 == nullptr && str16 == nullptr;
         }
-#endif
+        #endif
     };
 
-#if defined(FFI_SRC) && defined(_WINDOWS)
+    #if defined(FFI_SRC) && defined(_WINDOWS)
 
 
     inline std::wstring to_wstring(const char* str)
@@ -187,5 +195,5 @@ namespace Coplt
         return std::wstring(ca2_w);
     }
 
-#endif
+    #endif
 }
diff --git a/Coplt.Graphics.Native/Api/FFI/Types.h b/Coplt.Graphics.Native/Api/FFI/Types.h
index 535e1a3..f440899 100644
--- a/Coplt.Graphics.Native/Api/FFI/Types.h
+++ b/Coplt.Graphics.Native/Api/FFI/Types.h
@@ -7,6 +7,7 @@
 #ifdef FFI_SRC
 #include <type_traits>
 #include <glm/glm.hpp>
+#include <shared_mutex>
 
 #ifdef COPLT_X64
 #include <emmintrin.h>
@@ -30,7 +31,7 @@ namespace Coplt
     using i32 = int32_t;
     using i64 = int64_t;
 
-#ifdef FFI_SRC
+    #ifdef FFI_SRC
     using f32 = glm::f32;
     using f64 = glm::f64;
 
@@ -58,7 +59,11 @@ namespace Coplt
 
     using Char8 = char8_t;
     using Char16 = char16_t;
-#else
+
+    using RwLock = std::shared_mutex;
+    using WriteLock = std::unique_lock<RwLock>;
+    using ReadLock = std::shared_lock<RwLock>;
+    #else
     using f32 = float;
     using f64 = double;
 
@@ -86,7 +91,7 @@ namespace Coplt
 
     using Char8 = u8;
     using Char16 = u16;
-#endif
+    #endif
 
     struct Guid
     {
@@ -102,7 +107,7 @@ namespace Coplt
         u8 _j{};
         u8 _k{};
 
-#ifdef FFI_SRC
+        #ifdef FFI_SRC
         constexpr explicit Guid() = default;
 
         constexpr explicit Guid(
@@ -237,13 +242,13 @@ namespace Coplt
             }
             else
             {
-#ifdef COPLT_X64
+                #ifdef COPLT_X64
                 const __m128i a = _mm_loadu_si128(reinterpret_cast<const __m128i*>(this));
                 const __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&other));
                 const __m128i r = _mm_cmpeq_epi8(a, b);
                 const auto mask = _mm_movemask_epi8(r);
                 return mask == 0xFFFF;
-#else
+                #else
                 const auto src = reinterpret_cast<const u8*>(this);
                 const auto dst = reinterpret_cast<const u8*>(&other);
                 for (auto i = 0; i < sizeof(Guid); ++i)
@@ -251,7 +256,7 @@ namespace Coplt
                     if (src[i] != dst[i]) return false;
                 }
                 return true;
-#endif
+                #endif
             }
         }
 
@@ -295,6 +300,6 @@ namespace Coplt
             const auto r = static_cast<i32>(_a);
             return r ^ _a + 1 ^ _a + 2 ^ _a + 3;
         }
-#endif
+        #endif
     };
 }
diff --git a/Coplt.Graphics.Native/Api/Include/Error.h b/Coplt.Graphics.Native/Api/Include/Error.h
index 33d868a..97a9913 100644
--- a/Coplt.Graphics.Native/Api/Include/Error.h
+++ b/Coplt.Graphics.Native/Api/Include/Error.h
@@ -8,7 +8,6 @@
 
 #include "Logger.h"
 #include "../FFI/Result.h"
-#include "../Src/String.h"
 
 #if _WINDOWS
 #include <AtlBase.h>
@@ -16,23 +15,17 @@
 
 #include "Concepts.h"
 
+#ifdef _WINDOWS
+#define COPLT_THROW(msg) throw WRuntimeException(L##msg)
+#define COPLT_THROW_FMT(msg, ...) throw WRuntimeException(fmt::format(L##msg, __VA_ARGS__))
+#else
+#define COPLT_THROW(msg) throw RuntimeException(msg)
+#define COPLT_THROW_FMT(msg, ...) throw RuntimeException(fmt::format(msg, __VA_ARGS__))
+#endif
+
 namespace Coplt
 {
-    inline std::string to_string(const cpptrace::stacktrace& trace)
-    {
-        const auto trace8 = trace.to_string(false);
-        std::stringstream ss(trace8);
-        std::string tmp;
-        std::ostringstream stream{};
-        while (std::getline(ss, tmp, '\n'))
-        {
-            stream << "    ";
-            stream << tmp;
-            stream << "\r\n";
-        }
-        stream << "    --- End of native exception stack trace ---";
-        return std::move(stream).str();
-    }
+    std::string to_string(const cpptrace::stacktrace& trace);
 
     struct Exception
     {
@@ -48,26 +41,10 @@ namespace Coplt
         mutable std::string what_string;
 
     public:
-        explicit LazyException(
-            cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) : trace_holder(std::move(trace))
-        {
-        }
+        explicit LazyException(cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb());
 
-        std::string what() const noexcept override
-        {
-            if (what_string.empty())
-            {
-                const auto trace = to_string(trace_holder.get_resolved_trace());
-                what_string = fmt::format("{}\r\n{}", message().c_str(), trace.c_str());
-            }
-            return what_string;
-        }
-
-        const cpptrace::stacktrace& trace() const noexcept override
-        {
-            return trace_holder.get_resolved_trace();
-        }
+        std::string what() const noexcept override;
+        const cpptrace::stacktrace& trace() const noexcept override;
     };
 
     class ExceptionWithMessage : public LazyException
@@ -78,14 +55,9 @@ namespace Coplt
         explicit ExceptionWithMessage(
             std::string&& message_arg,
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept : LazyException(std::move(trace)), user_message(std::move(message_arg))
-        {
-        }
+        ) noexcept;
 
-        const std::string& message() const noexcept override
-        {
-            return user_message;
-        }
+        const std::string& message() const noexcept override;
     };
 
     class RuntimeException : public ExceptionWithMessage
@@ -94,37 +66,19 @@ namespace Coplt
         explicit RuntimeException(
             std::string&& message_arg,
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept
-            : ExceptionWithMessage(std::move(message_arg), std::move(trace))
-        {
-        }
+        ) noexcept;
 
         template <usize N>
         explicit RuntimeException(
             const char (&message_arg)[N],
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept
-            : RuntimeException(std::string(message_arg, N), std::move(trace))
+        ) noexcept : RuntimeException(std::string(message_arg, N), std::move(trace))
         {
         }
     };
 
-#if _WINDOWS
-    inline std::wstring to_wstring(const cpptrace::stacktrace& trace)
-    {
-        const auto trace8 = trace.to_string(false);
-        std::stringstream ss(trace8);
-        std::string tmp;
-        std::wostringstream stream{};
-        while (std::getline(ss, tmp, '\n'))
-        {
-            stream << L"    ";
-            stream << to_wstring(tmp.c_str());
-            stream << L"\r\n";
-        }
-        stream << L"    --- End of native exception stack trace ---";
-        return std::move(stream).str();
-    }
+    #ifdef _WINDOWS
+    std::wstring to_wstring(const cpptrace::stacktrace& trace);
 
     struct WException
     {
@@ -140,26 +94,11 @@ namespace Coplt
         mutable std::wstring what_string;
 
     public:
-        explicit WLazyException(
-            cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) : trace_holder(std::move(trace))
-        {
-        }
+        explicit WLazyException(cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb());
 
-        std::wstring what() const noexcept override
-        {
-            if (what_string.empty())
-            {
-                const auto trace = to_wstring(trace_holder.get_resolved_trace());
-                what_string = fmt::format(L"{}\r\n{}", message().c_str(), trace.c_str());
-            }
-            return what_string;
-        }
+        std::wstring what() const noexcept override;
 
-        const cpptrace::stacktrace& trace() const noexcept override
-        {
-            return trace_holder.get_resolved_trace();
-        }
+        const cpptrace::stacktrace& trace() const noexcept override;
     };
 
     class WExceptionWithMessage : public WLazyException
@@ -170,14 +109,9 @@ namespace Coplt
         explicit WExceptionWithMessage(
             std::wstring&& message_arg,
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept : WLazyException(std::move(trace)), user_message(std::move(message_arg))
-        {
-        }
+        ) noexcept;
 
-        const std::wstring& message() const noexcept override
-        {
-            return user_message;
-        }
+        const std::wstring& message() const noexcept override;
     };
 
     class WRuntimeException : public WExceptionWithMessage
@@ -186,10 +120,7 @@ namespace Coplt
         explicit WRuntimeException(
             std::wstring&& message_arg,
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept
-            : WExceptionWithMessage(std::move(message_arg), std::move(trace))
-        {
-        }
+        ) noexcept;
 
         template <usize N>
         explicit WRuntimeException(
@@ -207,10 +138,7 @@ namespace Coplt
         explicit ComException(
             std::wstring&& message_arg,
             cpptrace::raw_trace&& trace = cpptrace::detail::get_raw_trace_and_absorb()
-        ) noexcept
-            : WExceptionWithMessage(std::move(message_arg), std::move(trace))
-        {
-        }
+        ) noexcept;
 
         template <usize N>
         explicit ComException(
@@ -222,55 +150,66 @@ namespace Coplt
         }
     };
 
-#endif
+    #endif
+
+    template <Fn<FResult> F>
+    FResult feb(F f) noexcept;
 
+    template <Fn<void> F>
+    FResult feb(F f) noexcept;
+
+    template <class R, Fn<R> F>
+    R feb(Logger& logger, R r, F f) noexcept;
+}
+
+#include "../Src/String.h"
+
+namespace Coplt
+{
     template <Fn<FResult> F>
     FResult feb(F f) noexcept
     {
         FResult r;
         CPPTRACE_TRY
             {
-                CPPTRACE_TRY
-                    {
-                        try
-                        {
-                            r = f();
-                        }
-                        catch (FResult& e)
-                        {
-                            r = e;
-                        }
-                        catch (cpptrace::exception& e)
-                        {
-                            auto msg = std::string(e.what());
-                            r = FResult::Error(new CString(std::move(msg)));
-                        }
-                        catch (Exception& e)
-                        {
-                            const auto& msg = e.what();
-                            r = FResult::Error(String8::Create(msg.data(), msg.size()));
-                        }
-#ifdef _WINDOWS
-                        catch (WException& e)
-                        {
-                            const auto& msg = e.what();
-                            r = FResult::Error(String16::Create(msg.data(), msg.size()));
-                        }
-#endif
-                    }
-                CPPTRACE_CATCH(std::exception& ex)
+                try
+                {
+                    r = f();
+                }
+                catch (FResult& e)
+                {
+                    r = e;
+                }
+                catch (cpptrace::exception& e)
                 {
-                    const auto trace = to_string(cpptrace::from_current_exception());
-                    auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
-                    r = FResult::Error(new CString(std::move(msg)));
+                    auto msg = std::string(e.what());
+                    r = FResult::Error(CreateCString(std::move(msg)));
                 }
+                catch (Exception& e)
+                {
+                    const auto& msg = e.what();
+                    r = FResult::Error(CreateString8(msg.data(), msg.size()));
+                }
+                #ifdef _WINDOWS
+                catch (WException& e)
+                {
+                    const auto& msg = e.what();
+                    r = FResult::Error(CreateString16(msg.data(), msg.size()));
+                }
+                #endif
             }
-        CPPTRACE_CATCH(...)
+        CPPTRACE_CATCH(std::exception& ex)
+        {
+            const auto trace = to_string(cpptrace::from_current_exception());
+            auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
+            r = FResult::Error(CreateCString(std::move(msg)));
+        }
+        CPPTRACE_CATCH_ALT(...)
         {
             const auto trace = to_string(cpptrace::from_current_exception());
             auto msg = fmt::format(
                 "Unknown failure occurred. Possible memory corruption\r\n{}", trace.c_str());
-            r = FResult::Error(new CString(std::move(msg)));
+            r = FResult::Error(CreateCString(std::move(msg)));
         }
         return r;
     }
@@ -279,49 +218,47 @@ namespace Coplt
     FResult feb(F f) noexcept
     {
         FResult r = FResult::None();
+
         CPPTRACE_TRY
             {
-                CPPTRACE_TRY
-                    {
-                        try
-                        {
-                            f();
-                        }
-                        catch (FResult& e)
-                        {
-                            r = e;
-                        }
-                        catch (cpptrace::exception& e)
-                        {
-                            auto msg = std::string(e.what());
-                            r = FResult::Error(new CString(std::move(msg)));
-                        }
-                        catch (Exception& e)
-                        {
-                            const auto& msg = e.what();
-                            r = FResult::Error(String8::Create(msg.data(), msg.size()));
-                        }
-#ifdef _WINDOWS
-                        catch (WException& e)
-                        {
-                            const auto& msg = e.what();
-                            r = FResult::Error(String16::Create(msg.data(), msg.size()));
-                        }
-#endif
-                    }
-                CPPTRACE_CATCH(std::exception& ex)
+                try
+                {
+                    f();
+                }
+                catch (FResult& e)
+                {
+                    r = e;
+                }
+                catch (cpptrace::exception& e)
                 {
-                    const auto trace = to_string(cpptrace::from_current_exception());
-                    const auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
-                    r = FResult::Error(new CString(msg.data(), msg.size()));
+                    auto msg = std::string(e.what());
+                    r = FResult::Error(CreateCString(std::move(msg)));
                 }
+                catch (Exception& e)
+                {
+                    const auto& msg = e.what();
+                    r = FResult::Error(CreateString8(msg.data(), msg.size()));
+                }
+                #ifdef _WINDOWS
+                catch (WException& e)
+                {
+                    const auto& msg = e.what();
+                    r = FResult::Error(CreateString16(msg.data(), msg.size()));
+                }
+                #endif
             }
-        CPPTRACE_CATCH(...)
+        CPPTRACE_CATCH(std::exception& ex)
+        {
+            const auto trace = to_string(cpptrace::from_current_exception());
+            const auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
+            r = FResult::Error(CreateCString(msg.data(), msg.size()));
+        }
+        CPPTRACE_CATCH_ALT(...)
         {
             const auto trace = to_string(cpptrace::from_current_exception());
             const auto msg = fmt::format(
                 "Unknown failure occurred. Possible memory corruption\r\n{}", trace.c_str());
-            r = FResult::Error(new CString(msg.data(), msg.size()));
+            r = FResult::Error(CreateCString(msg.data(), msg.size()));
         }
         return r;
     }
@@ -331,42 +268,39 @@ namespace Coplt
     {
         CPPTRACE_TRY
             {
-                CPPTRACE_TRY
-                    {
-                        try
-                        {
-                            r = f();
-                        }
-                        catch (FResult& e)
-                        {
-                            logger.Log(FLogLevel::Error, FLogType::Common, e.msg);
-                            e.Drop();
-                        }
-                        catch (cpptrace::exception& e)
-                        {
-                            logger.Log(FLogLevel::Error, e.what());
-                        }
-                        catch (Exception& e)
-                        {
-                            const auto& msg = e.what();
-                            logger.Log(FLogLevel::Error, msg);
-                        }
-#ifdef _WINDOWS
-                        catch (WException& e)
-                        {
-                            const auto& msg = e.what();
-                            logger.LogW(FLogLevel::Error, msg);
-                        }
-#endif
-                    }
-                CPPTRACE_CATCH(std::exception& ex)
+                try
+                {
+                    r = f();
+                }
+                catch (FResult& e)
+                {
+                    logger.Log(FLogLevel::Error, FLogType::Common, e.msg);
+                    e.Drop();
+                }
+                catch (cpptrace::exception& e)
+                {
+                    logger.Log(FLogLevel::Error, e.what());
+                }
+                catch (Exception& e)
                 {
-                    const auto trace = to_string(cpptrace::from_current_exception());
-                    const auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
+                    const auto& msg = e.what();
                     logger.Log(FLogLevel::Error, msg);
                 }
+                #ifdef _WINDOWS
+                catch (WException& e)
+                {
+                    const auto& msg = e.what();
+                    logger.LogW(FLogLevel::Error, msg);
+                }
+                #endif
             }
-        CPPTRACE_CATCH(...)
+        CPPTRACE_CATCH(std::exception& ex)
+        {
+            const auto trace = to_string(cpptrace::from_current_exception());
+            const auto msg = fmt::format("{}\r\n{}", ex.what(), trace.c_str());
+            logger.Log(FLogLevel::Error, msg);
+        }
+        CPPTRACE_CATCH_ALT(...)
         {
             const auto trace = to_string(cpptrace::from_current_exception());
             const auto msg = fmt::format("Unknown failure occurred. Possible memory corruption\r\n{}", trace.c_str());
@@ -374,12 +308,4 @@ namespace Coplt
         }
         return r;
     }
-
-#ifdef _WINDOWS
-#define COPLT_THROW(msg) throw WRuntimeException(L##msg)
-#define COPLT_THROW_FMT(msg, ...) throw WRuntimeException(fmt::format(L##msg, __VA_ARGS__))
-#else
-#define COPLT_THROW(msg) throw RuntimeException(msg)
-#define COPLT_THROW_FMT(msg, ...) throw RuntimeException(fmt::format(msg, __VA_ARGS__))
-#endif
 }
diff --git a/Coplt.Graphics.Native/Api/Include/HashMap.h b/Coplt.Graphics.Native/Api/Include/HashMap.h
index b36966d..836fde6 100644
--- a/Coplt.Graphics.Native/Api/Include/HashMap.h
+++ b/Coplt.Graphics.Native/Api/Include/HashMap.h
@@ -59,6 +59,9 @@ namespace Coplt
     };
 
     template <class Key, class Value, Hash<Key> Hash = std::hash<Key>, Eq<Key> Eq = std::equal_to<Key>>
+    class HashMap;
+
+    template <class Key, class Value, Hash<Key> Hash , Eq<Key> Eq>
     class HashMap final
     {
         using HashHelpers = _HashMap_internal::HashHelpers;
@@ -863,6 +866,8 @@ namespace Coplt
             using pointer = Entry*;
             using reference = Entry&;
 
+            StdIterator() = default;
+
             explicit StdIterator(HashMap* self, const i32 index) : m_self(self), m_index(index)
             {
                 if (m_self) AdvanceToValid();
@@ -900,6 +905,7 @@ namespace Coplt
 
             bool operator==(const StdIterator& other) const
             {
+                if (m_self == nullptr || other.m_self == nullptr) return true;
                 return m_self == other.m_self && m_index == other.m_index;
             }
 
@@ -937,6 +943,8 @@ namespace Coplt
             using pointer = const Entry*;
             using reference = const Entry&;
 
+            ConstIterator() = default;
+
             explicit ConstIterator(const HashMap* self) : ConstIterator(self, 0)
             {
             }
@@ -974,6 +982,7 @@ namespace Coplt
 
             bool operator==(const ConstIterator& other) const
             {
+                if (m_self == nullptr || other.m_self == nullptr) return true;
                 return m_self == other.m_self && m_index == other.m_index;
             }
 
@@ -1016,4 +1025,626 @@ namespace Coplt
             return entries;
         }
     };
+
+    template <class Key, Hash<Key> Hash , Eq<Key> Eq>
+    class HashMap<Key, void, Hash, Eq> final
+    {
+        using HashHelpers = _HashMap_internal::HashHelpers;
+        using Slot = _HashMap_internal::Slot;
+
+        template <class T>
+        using UP = Uninit<T>&;
+        template <class T>
+        using RP = T&;
+
+    private:
+        i32* m_p_buckets{};
+        Slot* m_p_slots{};
+        Key* m_p_keys{};
+        u64 m_fast_mod_multiplier{};
+        u32 m_cap{};
+        i32 m_count{};
+        i32 m_free_list{};
+        i32 m_free_count{};
+        Hash m_hash{};
+        Eq m_eq{};
+
+        constexpr static i32 StartOfFreeList = -3;
+
+        std::span<Slot> Slots() const
+        {
+            return std::span(m_p_slots, m_cap);
+        }
+
+        std::span<Key> Keys() const
+        {
+            return std::span(m_p_keys, m_cap);
+        }
+
+    public:
+        HashMap() = default;
+
+        ~HashMap()
+        {
+            if (m_p_buckets != nullptr)
+            {
+                mi_free_aligned(m_p_buckets, alignof(i32));
+            }
+            if (m_p_slots != nullptr)
+            {
+                mi_free_aligned(m_p_slots, alignof(Slot));
+            }
+            if (m_p_keys != nullptr)
+            {
+                if constexpr (!std::is_trivially_destructible<Key>())
+                {
+                    auto iter = Iterator();
+                    while (auto key = iter.Next())
+                    {
+                        key->~Key();
+                    }
+                }
+                mi_free_aligned(m_p_keys, alignof(Key));
+            }
+        }
+
+        HashMap(HashMap&& other) noexcept
+            : m_p_buckets(std::exchange(other.m_p_buckets, nullptr)),
+              m_p_slots(std::exchange(other.m_p_slots, nullptr)),
+              m_p_keys(std::exchange(other.m_p_keys, nullptr)),
+              m_fast_mod_multiplier(std::exchange(other.m_fast_mod_multiplier, 0)),
+              m_cap(std::exchange(other.m_cap, 0)),
+              m_count(std::exchange(other.m_count, 0)),
+              m_free_list(std::exchange(other.m_free_list, 0))
+        {
+        }
+
+        HashMap& operator=(HashMap&& other) noexcept
+        {
+            if (this == &other) return *this;
+            new HashMap(std::move(*this));
+            new(this) HashMap(std::forward<HashMap>(other));
+            return *this;
+        }
+
+        HashMap(HashMap& other) noexcept = delete;
+
+        HashMap& operator=(HashMap& other) = delete;
+
+        usize Count() const noexcept
+        {
+            return m_count;
+        }
+
+        bool IsEmpty() const noexcept
+        {
+            return m_count == 0;
+        }
+
+    private:
+        i32 Initialize(const i32 capacity)
+        {
+            const auto size = HashHelpers::GetPrime(capacity);
+
+            m_cap = size;
+            m_p_buckets = static_cast<i32*>(mi_zalloc_aligned(size * sizeof(i32), alignof(i32)));
+            m_p_slots = static_cast<Slot*>(mi_zalloc_aligned(size * sizeof(Slot), alignof(Slot)));
+            m_p_keys = static_cast<Key*>(mi_malloc_aligned(size * sizeof(Key), alignof(Key)));
+
+            m_free_list = -1;
+            m_fast_mod_multiplier = HashHelpers::GetFastModMultiplier(static_cast<u32>(size));
+
+            return size;
+        }
+
+        i32* GetBucket(const usize hash_code) const
+        {
+            const auto index = HashHelpers::FastMod(hash_code, m_cap, m_fast_mod_multiplier);
+            return &m_p_buckets[index];
+        }
+
+        void Resize()
+        {
+            Resize(HashHelpers::ExpandPrime(m_count));
+        }
+
+        void Resize(i32 new_size)
+        {
+            m_cap = new_size;
+            mi_free_aligned(m_p_buckets, alignof(i32));
+            m_p_buckets = static_cast<i32*>(mi_zalloc_aligned(new_size * sizeof(i32), alignof(i32)));
+            m_p_slots = static_cast<Slot*>(mi_rezalloc_aligned(m_p_slots, new_size * sizeof(Slot), alignof(Slot)));
+            m_p_keys = static_cast<Key*>(
+                mi_realloc_aligned(m_p_keys, new_size * sizeof(Key), alignof(Key))
+            );
+            m_fast_mod_multiplier = HashHelpers::GetFastModMultiplier(static_cast<u32>(new_size));
+
+            const auto count = m_count;
+            for (int i = 0; i < count; i++)
+            {
+                if (auto& slot = m_p_slots[i]; slot.next >= -1)
+                {
+                    const auto bucket = GetBucket(slot.hash_code());
+                    slot.next = *bucket - 1; // Value in _buckets is 1-based
+                    *bucket = i + 1;
+                }
+            }
+        }
+
+    public:
+        // 返回是否成功添加，false 表示已经存在
+        template <Fn<const Key&> QueryKey, Fn<void, UP<Key>> CreateKey>
+        bool Add(QueryKey query_key, CreateKey create_key)
+        {
+            if (m_p_buckets == nullptr) Initialize(0);
+
+            const Key& key = query_key();
+            const usize hash_code = m_hash(key);
+
+            u32 collision_count = 0;
+            auto bucket = GetBucket(hash_code);
+            auto i = *bucket - 1;
+
+            while (static_cast<u32>(i) < m_cap)
+            {
+                auto& slot = m_p_slots[i];
+                auto& slot_key = m_p_keys[i];
+                if (slot.hash_code() == hash_code && m_eq(slot_key, key))
+                {
+                    return false;
+                }
+
+                i = slot.next;
+
+                collision_count++;
+                if (collision_count >= m_cap)
+                {
+                    throw std::out_of_range("HashMap does not support concurrent operations");
+                }
+            }
+
+            i32 index{};
+            if (m_free_count > 0)
+            {
+                index = m_free_list;
+                m_free_list = StartOfFreeList - m_p_slots[m_free_list].next;
+                m_free_count--;
+            }
+            else
+            {
+                const auto count = m_count;
+                if (count == m_cap)
+                {
+                    Resize();
+                    bucket = GetBucket(hash_code);
+                }
+                index = count;
+                m_count = count + 1;
+            }
+
+            auto& slot = m_p_slots[index];
+            auto& slot_key = m_p_keys[index];
+            slot.hash_code() = hash_code;
+            slot.next = *bucket - 1;
+            Uninit<Key> u_key(slot_key);
+            create_key(u_key);
+            *bucket = index + 1;
+
+            return true;
+        }
+
+        // 返回是否成功添加，false 表示已经存在
+        bool Add(Key&& key)
+        {
+            return Add(
+                [&] -> const Key& { return key; },
+                [&](UP<Key> p) -> void { new(p.unsafe_put()) Key(std::move(key)); }
+            );
+        }
+
+        // 返回是否成功添加，false 表示已经存在
+        bool Add(const Key& key)
+        {
+            return Add(
+                [&] -> const Key& { return key; },
+                [&](UP<Key> p) -> void { new(p.unsafe_put()) Key(key); }
+            );
+        }
+
+        template <class QKey, Coplt::Hash<QKey> QHash = std::hash<QKey>, Coplt::Eq<Key, QKey> QEq = std::equal_to<Key>>
+        bool Contains(const QKey& query_key, QHash hasher, QEq eq) const
+        {
+            Slot* slot = nullptr;
+            Key* slot_key = nullptr;
+            if (m_p_buckets == nullptr) return false;
+
+            auto hash_code = hasher(query_key);
+            auto i = *GetBucket(hash_code);
+            u32 collision_count = 0;
+
+            --i;
+            // Value in _buckets is 1-based; subtract 1 from i. We do it here so it fuses with the following conditional.
+            do
+            {
+                if (static_cast<u32>(i) >= m_cap)
+                {
+                    return false;
+                }
+
+                slot = std::addressof(m_p_slots[i]);
+                slot_key = std::addressof(m_p_keys[i]);
+                if (slot->hash_code() == hash_code && eq(*slot_key, query_key))
+                {
+                    return true;
+                }
+
+                i = slot->next;
+
+                collision_count++;
+            }
+            while (collision_count <= m_cap);
+
+            // The chain of entries forms a loop; which means a concurrent update has happened.
+            // Break out of the loop and throw, rather than looping forever.
+            throw std::out_of_range("HashMap does not support concurrent operations");
+        }
+
+        bool Contains(const Key& key) const
+        {
+            return Contains(key, m_hash, m_eq);
+        }
+
+        // 返回是否删除，如果删除并且 out_key 不为空将写入 out_key
+        template <class QKey, Coplt::Hash<QKey> QHash = std::hash<QKey>, Coplt::Eq<Key, QKey> QEq = std::equal_to<Key>>
+        bool Remove(const QKey& query_key, QHash hasher, QEq eq, Key* out_key)
+        {
+            if (m_p_buckets == nullptr) return false;
+            u32 collision_count = 0;
+            auto hash_code = hasher(query_key);
+            auto bucket = GetBucket(hash_code);
+            i32 last = -1;
+            i32 i = *bucket - 1; // Value in buckets is 1-based
+            while (i >= 0)
+            {
+                auto& slot = m_p_slots[i];
+                auto& slot_key = m_p_keys[i];
+
+                if (slot.hash_code() == hash_code && eq(slot_key, query_key))
+                {
+                    if (last < 0)
+                    {
+                        *bucket = slot.next + 1; // Value in buckets is 1-based
+                    }
+                    else
+                    {
+                        m_p_slots[last].next = slot.next;
+                    }
+
+                    slot.next = StartOfFreeList - m_free_list;
+
+                    if (out_key != nullptr)
+                    {
+                        *out_key = std::move(slot_key);
+                    }
+                    if constexpr (std::is_trivially_destructible<Key>())
+                    {
+                        slot_key.~Key();
+                    }
+
+                    m_free_list = i;
+                    m_free_count++;
+                    return true;
+                }
+
+                last = i;
+                i = slot.next;
+
+                collision_count++;
+                if (collision_count > m_cap)
+                {
+                    throw std::out_of_range("HashMap does not support concurrent operations");
+                }
+            }
+            return false;
+        }
+
+        // 返回是否删除
+        template <class QKey, Coplt::Hash<QKey> QHash = std::hash<QKey>, Coplt::Eq<Key, QKey> QEq = std::equal_to<Key>>
+        bool Remove(const QKey& query_key, QHash hasher, QEq eq)
+        {
+            return Remove(query_key, fove(hasher), fove(eq), nullptr);
+        }
+
+        // 返回是否删除，如果删除并且 out_key 不为空将写入 out_key
+        bool Remove(const Key& key, Key* out_key)
+        {
+            return Remove(key, m_hash, m_eq, out_key);
+        }
+
+        // 返回是否删除
+        bool Remove(const Key& key)
+        {
+            return Remove(key, m_hash, m_eq, nullptr);
+        }
+
+        void Clear()
+        {
+            if (m_count > 0)
+            {
+                if constexpr (!std::is_trivially_destructible<Key>())
+                {
+                    auto iter = Iterator();
+                    while (auto key = iter.Next())
+                    {
+                        key->~Key();
+                    }
+                }
+
+                std::fill_n(m_p_buckets, m_cap, 0);
+                std::fill_n(m_p_slots, m_cap, Slot{});
+
+                m_count = 0;
+                m_free_list = -1;
+                m_free_count = 0;
+            }
+        }
+
+        class MutIterator
+        {
+            HashMap* m_self{};
+            i32 m_index{0};
+
+        public:
+            explicit MutIterator(HashMap* self) : m_self(self)
+            {
+            }
+
+            // 尝试获取下个项，如果成功获取将不是 null
+            Key* Next()
+            {
+                while (static_cast<u32>(m_index) < static_cast<u32>(m_self->m_count))
+                {
+                    auto i = m_index++;
+                    auto& slot = m_self->m_p_slots[i];
+                    auto& slot_key = m_self->m_p_keys[i];
+
+                    if (slot.next >= -1)
+                    {
+                        return std::addressof(slot_key);
+                    }
+                }
+
+                m_index = m_self->m_count + 1;
+                return nullptr;
+            }
+        };
+
+        MutIterator Iterator()
+        {
+            return MutIterator(this);
+        }
+
+        class ImmIterator
+        {
+            const HashMap* m_self{};
+            i32 m_index{0};
+
+        public:
+            explicit ImmIterator(const HashMap* self) : m_self(self)
+            {
+            }
+
+            // 尝试获取下个项，如果成功获取将不是 null
+            const Key* Next()
+            {
+                while (static_cast<u32>(m_index) < static_cast<u32>(m_self->m_count))
+                {
+                    auto i = m_index++;
+                    auto& slot = m_self->m_p_slots[i];
+                    auto& slot_key = m_self->m_p_keys[i];
+
+                    if (slot.next >= -1)
+                    {
+                        return std::addressof(slot_key);
+                    }
+                }
+
+                m_index = m_self->m_count + 1;
+                return nullptr;
+            }
+        };
+
+        ImmIterator Iterator() const
+        {
+            return ImmIterator(this);
+        }
+
+        class StdIterator
+        {
+            HashMap* m_self{};
+            i32 m_index{0};
+
+            void AdvanceToValid()
+            {
+                while (m_self && m_index < m_self->m_count)
+                {
+                    auto& slot = m_self->m_p_slots[m_index];
+                    if (slot.next >= -1)
+                    {
+                        break;
+                    }
+                    ++m_index;
+                }
+            }
+
+        public:
+            using iterator_category = std::forward_iterator_tag;
+            using iterator_concept = std::forward_iterator_tag;
+            using value_type = Key;
+            using difference_type = std::ptrdiff_t;;
+            using pointer = Key*;
+            using reference = Key&;
+
+            StdIterator() = default;
+
+            explicit StdIterator(HashMap* self, const i32 index) : m_self(self), m_index(index)
+            {
+                if (m_self) AdvanceToValid();
+            }
+
+            explicit StdIterator(HashMap* self) : StdIterator(self, 0)
+            {
+            }
+
+            Key& operator*() const
+            {
+                return m_self->m_p_keys[m_index];
+            }
+
+            Key* operator->() const
+            {
+                return &m_self->m_p_keys[m_index];
+            }
+
+            // 前缀增量
+            StdIterator& operator++()
+            {
+                ++m_index;
+                AdvanceToValid();
+                return *this;
+            }
+
+            // 后缀增量
+            StdIterator operator++(int)
+            {
+                StdIterator temp = *this;
+                ++(*this);
+                return temp;
+            }
+
+            bool operator==(const StdIterator& other) const
+            {
+                if (m_self == nullptr || other.m_self == nullptr) return true;
+                return m_self == other.m_self && m_index == other.m_index;
+            }
+
+            bool operator!=(const StdIterator& other) const
+            {
+                return !(*this == other);
+            }
+        };
+
+        using iterator = StdIterator;
+
+        class ConstIterator
+        {
+            const HashMap* m_self{};
+            i32 m_index{0};
+
+            void AdvanceToValid()
+            {
+                while (m_self && m_index < m_self->m_count)
+                {
+                    auto& slot = m_self->m_p_slots[m_index];
+                    if (slot.next >= -1)
+                    {
+                        break;
+                    }
+                    ++m_index;
+                }
+            }
+
+        public:
+            using iterator_category = std::forward_iterator_tag;
+            using iterator_concept = std::forward_iterator_tag;
+            using value_type = Key;
+            using difference_type = std::ptrdiff_t;;
+            using pointer = const Key*;
+            using reference = const Key&;
+
+            ConstIterator() = default;
+
+            explicit ConstIterator(const HashMap* self) : ConstIterator(self, 0)
+            {
+            }
+
+            explicit ConstIterator(const HashMap* self, const i32 index) : m_self(self), m_index(index)
+            {
+                if (m_self) AdvanceToValid();
+            }
+
+            const Key& operator*() const
+            {
+                return m_self->m_p_keys[m_index];
+            }
+
+            const Key* operator->() const
+            {
+                return &m_self->m_p_keys[m_index];
+            }
+
+            // 前缀增量
+            ConstIterator& operator++()
+            {
+                ++m_index;
+                AdvanceToValid();
+                return *this;
+            }
+
+            // 后缀增量
+            ConstIterator operator++(int)
+            {
+                ConstIterator temp = *this;
+                ++(*this);
+                return temp;
+            }
+
+            bool operator==(const ConstIterator& other) const
+            {
+                if (m_self == nullptr || other.m_self == nullptr) return true;
+                return m_self == other.m_self && m_index == other.m_index;
+            }
+
+            bool operator!=(const ConstIterator& other) const
+            {
+                return !(*this == other);
+            }
+        };
+
+        iterator begin()
+        {
+            return iterator(this);
+        }
+
+        iterator end()
+        {
+            return iterator(this, m_count);
+        }
+
+        ConstIterator begin() const
+        {
+            return ConstIterator(this);
+        }
+
+        ConstIterator end() const
+        {
+            return ConstIterator(this, m_count);
+        }
+
+        std::vector<Key> IntoVector() &&
+        {
+            std::vector<Key> keys{};
+            keys.reserve(m_count);
+            auto iter = Iterator();
+            while (auto key = iter.Next())
+            {
+                keys.push_back(std::move(*key));
+            }
+            new HashMap(std::move(*this));
+            return keys;
+        }
+    };
+
+    template <class Key, Hash<Key> Hash = std::hash<Key>, Eq<Key> Eq = std::equal_to<Key>>
+    using HashSet = HashMap<Key, void, Hash, Eq>;
 }
diff --git a/Coplt.Graphics.Native/Api/Include/Object.h b/Coplt.Graphics.Native/Api/Include/Object.h
index 8c50f35..58f8f04 100644
--- a/Coplt.Graphics.Native/Api/Include/Object.h
+++ b/Coplt.Graphics.Native/Api/Include/Object.h
@@ -80,15 +80,9 @@ namespace Coplt
             return m_ptr;
         }
 
-        T& operator*() const
-        {
-            return *get();
-        }
+        T& operator*() const;
 
-        T* operator->() const
-        {
-            return get();
-        }
+        T* operator->() const;
 
         T* operator&() const
         {
@@ -647,3 +641,26 @@ namespace Coplt
         return ptr->template QueryInterface<U>();
     }
 }
+
+#include "Error.h"
+
+namespace Coplt
+{
+    template <class T>
+    T& Rc<T>::operator*() const
+    {
+        const auto ptr = get();
+        if (ptr == nullptr) [[unlikely]]
+            COPLT_THROW("Null Pointer");
+        return *ptr;
+    }
+
+    template <class T>
+    T* Rc<T>::operator->() const
+    {
+        const auto ptr = get();
+        if (ptr == nullptr) [[unlikely]]
+            COPLT_THROW("Null Pointer");
+        return ptr;
+    }
+}
diff --git a/Coplt.Graphics.Native/Api/Include/Ptr.h b/Coplt.Graphics.Native/Api/Include/Ptr.h
new file mode 100644
index 0000000..1932659
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/Include/Ptr.h
@@ -0,0 +1,388 @@
+#pragma once
+
+#include <utility>
+#include "Error.h"
+
+namespace Coplt
+{
+    template <class T>
+    using Pointer = T*;
+
+    template <class T>
+    class Ptr;
+    template <class T>
+    class NonNull;
+
+    template <class T>
+    class Ptr
+    {
+        T* m_ptr;
+
+        template <class A>
+        friend class Ptr;
+        template <class A>
+        friend class NonNull;
+
+    public:
+        Ptr() noexcept : m_ptr(nullptr)
+        {
+        }
+
+        explicit Ptr(T& ref) noexcept : m_ptr(std::addressof(ref))
+        {
+        }
+
+        Ptr(T* ptr) noexcept : m_ptr(ptr)
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr(U* ptr) noexcept : m_ptr(ptr)
+        {
+        }
+
+        Ptr(const Rc<T>& rc) noexcept : m_ptr(rc.get())
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr(const Rc<U>& rc) noexcept : m_ptr(rc.get())
+        {
+        }
+
+        Ptr(Ptr&& other) noexcept : m_ptr(std::exchange(other.m_ptr, nullptr))
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr(Ptr<U>&& other) noexcept : m_ptr(std::exchange(other.m_ptr, nullptr))
+        {
+        }
+
+        Ptr(const Ptr& other) noexcept : m_ptr(other.m_ptr)
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr(const Ptr<U>& other) noexcept : m_ptr(other.m_ptr)
+        {
+        }
+
+        Ptr& swap(Ptr& other) noexcept
+        {
+            std::swap(m_ptr, other.m_ptr);
+            return *this;
+        }
+
+        Ptr& operator=(Ptr&& other) noexcept
+        {
+            Ptr(std::forward<Ptr>(other)).swap(*this);
+            return *this;
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr& operator=(Ptr<U>&& other) noexcept
+        {
+            Ptr(std::forward<Ptr<U>>(other)).swap(*this);
+            return *this;
+        }
+
+        Ptr& operator=(const Ptr& other) noexcept
+        {
+            Ptr(other).swap(*this);
+            return *this;
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        Ptr& operator=(const Ptr<U>& other) noexcept
+        {
+            Ptr(other).swap(*this);
+            return *this;
+        }
+
+        operator T*() const noexcept
+        {
+            return m_ptr;
+        }
+
+        template <class U> requires std::convertible_to<T*, U*>
+        operator U*() const noexcept
+        {
+            return m_ptr;
+        }
+
+        T** operator&() noexcept
+        {
+            return &m_ptr;
+        }
+
+        T* const* operator&() const noexcept
+        {
+            return &m_ptr;
+        }
+
+        T* operator->() const
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+            return m_ptr;
+        }
+
+        T& operator*() const
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+            return *m_ptr;
+        }
+
+        operator bool() const noexcept
+        {
+            return m_ptr != nullptr;
+        }
+
+        bool operator==(std::nullptr_t) const noexcept
+        {
+            return m_ptr == nullptr;
+        }
+
+        T* get() const noexcept
+        {
+            return m_ptr;
+        }
+
+        bool operator==(const Pointer<T>& ptr) const noexcept
+        {
+            return m_ptr == ptr;
+        }
+
+        template <class U> requires std::convertible_to<T*, U*> || std::convertible_to<U*, U*>
+        bool operator==(const Pointer<U>& ptr) const noexcept
+        {
+            return m_ptr == ptr;
+        }
+
+        explicit operator usize() const noexcept
+        {
+            return reinterpret_cast<usize>(m_ptr);
+        }
+
+        Ptr operator[](usize offset) const noexcept
+        {
+            return Ptr(m_ptr + offset);
+        }
+
+        Ptr operator+(usize offset) const noexcept
+        {
+            return Ptr(m_ptr + offset);
+        }
+
+        Ptr operator-(usize offset) const noexcept
+        {
+            return Ptr(m_ptr - offset);
+        }
+    };
+
+    template <class T>
+    class NonNull
+    {
+        T* m_ptr;
+
+        template <class A>
+        friend class NonNull;
+        template <class A>
+        friend class Ptr;
+
+        struct Unchecked_t
+        {
+        };
+
+        NonNull(T* ptr, Unchecked_t) : m_ptr(ptr)
+        {
+        }
+
+    public:
+        NonNull() = delete;
+
+        static NonNull Unchecked(T* ptr) noexcept
+        {
+            return NonNull(ptr, Unchecked_t());
+        }
+
+        explicit NonNull(T& ref) noexcept : m_ptr(std::addressof(ref))
+        {
+        }
+
+        NonNull(T* ptr) : m_ptr(ptr)
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull(U* ptr) : m_ptr(ptr)
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+        }
+
+        NonNull(const Rc<T>& rc) : NonNull(rc.get())
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull(const Rc<U>& rc) : NonNull(rc.get())
+        {
+        }
+
+        NonNull(Ptr<T> ptr) : m_ptr(ptr.m_ptr)
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull(Ptr<U> ptr) : m_ptr(ptr.m_ptr)
+        {
+            if (m_ptr == nullptr) [[unlikely]]
+                COPLT_THROW("Null Pointer");
+        }
+
+        NonNull(NonNull&& other) noexcept : m_ptr(std::exchange(other.m_ptr, nullptr))
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull(NonNull<U>&& other) noexcept : m_ptr(std::exchange(other.m_ptr, nullptr))
+        {
+        }
+
+        NonNull(const NonNull& other) noexcept : m_ptr(other.m_ptr)
+        {
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull(const NonNull<U>& other) noexcept : m_ptr(other.m_ptr)
+        {
+        }
+
+        NonNull& swap(NonNull& other) noexcept
+        {
+            std::swap(m_ptr, other.m_ptr);
+            return *this;
+        }
+
+        NonNull& operator=(NonNull&& other) noexcept
+        {
+            NonNull(std::forward<NonNull>(other)).swap(*this);
+            return *this;
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull& operator=(NonNull<U>&& other) noexcept
+        {
+            NonNull(std::forward<NonNull<U>>(other)).swap(*this);
+            return *this;
+        }
+
+        NonNull& operator=(const NonNull& other) noexcept
+        {
+            NonNull(other).swap(*this);
+            return *this;
+        }
+
+        template <class U> requires std::convertible_to<U*, T*>
+        NonNull& operator=(const NonNull<U>& other) noexcept
+        {
+            NonNull(other).swap(*this);
+            return *this;
+        }
+
+        operator T*() const noexcept
+        {
+            return m_ptr;
+        }
+
+        template <class U> requires std::convertible_to<T*, U*>
+        operator U*() const noexcept
+        {
+            return m_ptr;
+        }
+
+        T** operator&() noexcept
+        {
+            return &m_ptr;
+        }
+
+        T* const* operator&() const noexcept
+        {
+            return &m_ptr;
+        }
+
+        T* operator->() const noexcept
+        {
+            return m_ptr;
+        }
+
+        T& operator*() const noexcept
+        {
+            return *m_ptr;
+        }
+
+        operator bool() const noexcept
+        {
+            return true;
+        }
+
+        bool operator==(std::nullptr_t) const noexcept
+        {
+            return false;
+        }
+
+        T* get() const noexcept
+        {
+            return m_ptr;
+        }
+
+        bool operator==(const Pointer<T>& ptr) const noexcept
+        {
+            return m_ptr == ptr;
+        }
+
+        template <class U> requires std::convertible_to<T*, U*> || std::convertible_to<U*, U*>
+        bool operator==(const Pointer<U>& ptr) const noexcept
+        {
+            return m_ptr == ptr;
+        }
+
+        bool operator==(const Ptr<T>& ptr) const noexcept
+        {
+            return m_ptr == ptr.m_ptr;
+        }
+
+        template <class U> requires std::convertible_to<T*, U*> || std::convertible_to<U*, U*>
+        bool operator==(const Ptr<U>& ptr) const noexcept
+        {
+            return m_ptr == ptr.m_ptr;
+        }
+
+        explicit operator usize() const noexcept
+        {
+            return reinterpret_cast<usize>(m_ptr);
+        }
+
+        NonNull operator[](usize offset) const noexcept
+        {
+            return NonNull(m_ptr + offset);
+        }
+
+        NonNull operator+(usize offset) const noexcept
+        {
+            return NonNull(m_ptr + offset);
+        }
+
+        NonNull operator-(usize offset) const noexcept
+        {
+            return NonNull(m_ptr - offset);
+        }
+    };
+}
diff --git a/Coplt.Graphics.Native/Api/Src/Error.cc b/Coplt.Graphics.Native/Api/Src/Error.cc
new file mode 100644
index 0000000..0d0a10e
--- /dev/null
+++ b/Coplt.Graphics.Native/Api/Src/Error.cc
@@ -0,0 +1,111 @@
+#include "../Include/Error.h"
+
+using namespace Coplt;
+
+std::string Coplt::to_string(const cpptrace::stacktrace& trace)
+{
+    const auto trace8 = trace.to_string(false);
+    std::stringstream ss(trace8);
+    std::string tmp;
+    std::ostringstream stream{};
+    while (std::getline(ss, tmp, '\n'))
+    {
+        stream << "    ";
+        stream << tmp;
+        stream << "\r\n";
+    }
+    stream << "    --- End of native exception stack trace ---";
+    return std::move(stream).str();
+}
+
+LazyException::LazyException(cpptrace::raw_trace&& trace) : trace_holder(std::move(trace))
+{
+}
+
+std::string LazyException::what() const noexcept
+{
+    if (what_string.empty())
+    {
+        const auto trace = to_string(trace_holder.get_resolved_trace());
+        what_string = fmt::format("{}\r\n{}", message().c_str(), trace.c_str());
+    }
+    return what_string;
+}
+
+const cpptrace::stacktrace& LazyException::trace() const noexcept
+{
+    return trace_holder.get_resolved_trace();
+}
+
+ExceptionWithMessage::ExceptionWithMessage(std::string&& message_arg, cpptrace::raw_trace&& trace) noexcept
+    : LazyException(std::move(trace)), user_message(std::move(message_arg))
+{
+}
+
+const std::string& ExceptionWithMessage::message() const noexcept
+{
+    return user_message;
+}
+
+RuntimeException::RuntimeException(std::string&& message_arg, cpptrace::raw_trace&& trace) noexcept
+    : ExceptionWithMessage(std::move(message_arg), std::move(trace))
+{
+}
+
+#ifdef _WINDOWS
+std::wstring Coplt::to_wstring(const cpptrace::stacktrace& trace)
+{
+    const auto trace8 = trace.to_string(false);
+    std::stringstream ss(trace8);
+    std::string tmp;
+    std::wostringstream stream{};
+    while (std::getline(ss, tmp, '\n'))
+    {
+        stream << L"    ";
+        stream << to_wstring(tmp.c_str());
+        stream << L"\r\n";
+    }
+    stream << L"    --- End of native exception stack trace ---";
+    return std::move(stream).str();
+}
+
+WLazyException::WLazyException(cpptrace::raw_trace&& trace) : trace_holder(std::move(trace))
+{
+}
+
+std::wstring WLazyException::what() const noexcept
+{
+    if (what_string.empty())
+    {
+        const auto trace = to_wstring(trace_holder.get_resolved_trace());
+        what_string = fmt::format(L"{}\r\n{}", message().c_str(), trace.c_str());
+    }
+    return what_string;
+}
+
+const cpptrace::stacktrace& WLazyException::trace() const noexcept
+{
+    return trace_holder.get_resolved_trace();
+}
+
+WExceptionWithMessage::WExceptionWithMessage(std::wstring&& message_arg, cpptrace::raw_trace&& trace) noexcept
+    : WLazyException(std::move(trace)), user_message(std::move(message_arg))
+{
+}
+
+const std::wstring& WExceptionWithMessage::message() const noexcept
+{
+    return user_message;
+}
+
+WRuntimeException::WRuntimeException(std::wstring&& message_arg, cpptrace::raw_trace&& trace) noexcept
+    : WExceptionWithMessage(std::move(message_arg), std::move(trace))
+{
+}
+
+ComException::ComException(std::wstring&& message_arg, cpptrace::raw_trace&& trace) noexcept
+    : WExceptionWithMessage(std::move(message_arg), std::move(trace))
+{
+}
+
+#endif
diff --git a/Coplt.Graphics.Native/Api/Src/String.cc b/Coplt.Graphics.Native/Api/Src/String.cc
index 8112967..a8cdf3a 100644
--- a/Coplt.Graphics.Native/Api/Src/String.cc
+++ b/Coplt.Graphics.Native/Api/Src/String.cc
@@ -2,14 +2,102 @@
 
 using namespace Coplt;
 
-FString* FStr8or16::ToString() const
+FString* Coplt::ToString(const FStr8or16& str)
 {
-    switch (type)
+    switch (str.type)
     {
     case FStrType::Str16:
-        return String16::Create(str16, len);
+        return String16::Create(str.str16, str.len);
     case FStrType::Str8:
-        return String8::Create(str8, len);
+        return String8::Create(str.str8, str.len);
     }
     return nullptr;
 }
+
+String8* String8::Create(const char8_t* data)
+{
+    return StringT::Create(data);
+}
+
+String8* String8::Create(const char* data)
+{
+    return Create(data, std::char_traits<char>::length(data));
+}
+
+String8* String8::Create(const char8_t* data, const usize size)
+{
+    return StringT::Create(data, size);
+}
+
+String8* String8::Create(const char* data, const usize size)
+{
+    return StringT::Create(reinterpret_cast<const char8_t*>(data), size);
+}
+
+FStr8or16 String8::GetStr() const noexcept
+{
+    return FStr8or16(c_str(), size());
+}
+
+String8* Coplt::CreateString8(const char* data, const usize size)
+{
+    return String8::Create(data, size);
+}
+
+String16::String16(const char16_t* data, const usize size) : StringT(data, size)
+{
+}
+
+String16* String16::Create(const Char16* data)
+{
+    return StringT::Create(data);
+}
+
+String16* String16::Create(const Char16* data, const usize size)
+{
+    return StringT::Create(data, size);
+}
+
+#ifdef _WINDOWS
+String16* String16::Create(const wchar_t* data)
+{
+    return Create(data, std::char_traits<wchar_t>::length(data));
+}
+
+String16* String16::Create(const wchar_t* data, const usize size)
+{
+    return StringT::Create(reinterpret_cast<const char16_t*>(data), size);
+}
+#endif
+
+FStr8or16 String16::GetStr() const noexcept
+{
+    return FStr8or16(data(), size());
+}
+
+String16* Coplt::CreateString16(const wchar_t* data, const usize size)
+{
+    return String16::Create(data, size);
+}
+
+FStr8or16 CString::GetStr() const noexcept
+{
+    return FStr8or16(data(), size());
+}
+
+CString* Coplt::CreateCString(std::string&& string)
+{
+    return new CString(std::forward<std::string>(string));
+}
+
+CString* Coplt::CreateCString(const char* data, const usize size)
+{
+    return new CString(data, size);
+}
+
+#ifdef _WINDOWS
+FStr8or16 WString::GetStr() const noexcept
+{
+    return FStr8or16(data(), size());
+}
+#endif
diff --git a/Coplt.Graphics.Native/Api/Src/String.h b/Coplt.Graphics.Native/Api/Src/String.h
index 8f7a374..dbc6ef8 100644
--- a/Coplt.Graphics.Native/Api/Src/String.h
+++ b/Coplt.Graphics.Native/Api/Src/String.h
@@ -121,25 +121,13 @@ namespace Coplt
         }
 
     public:
-        static String8* Create(const char8_t* data)
-        {
-            return StringT::Create(data);
-        }
+        static String8* Create(const char8_t* data);
 
-        static String8* Create(const char* data)
-        {
-            return Create(data, std::char_traits<char>::length(data));
-        }
+        static String8* Create(const char* data);
 
-        static String8* Create(const char8_t* data, const usize size)
-        {
-            return StringT::Create(data, size);
-        }
+        static String8* Create(const char8_t* data, const usize size);
 
-        static String8* Create(const char* data, const usize size)
-        {
-            return StringT::Create(reinterpret_cast<const char8_t*>(data), size);
-        }
+        static String8* Create(const char* data, const usize size);
 
         constexpr const char* c_str() const
         {
@@ -151,42 +139,27 @@ namespace Coplt
             return std::string(c_str(), m_size);
         }
 
-        FStr8or16 GetStr() const noexcept override
-        {
-            return FStr8or16(c_str(), size());
-        }
+        FStr8or16 GetStr() const noexcept override;
     };
 
+    extern String8* CreateString8(const char* data, usize size);
+
     struct String16 final : StringT<String16, char16_t, FString16>
     {
     private:
         friend StringT;
 
-        explicit String16(const char16_t* data, const usize size) : StringT(data, size)
-        {
-        }
+        explicit String16(const char16_t* data, const usize size);
 
     public:
-        static String16* Create(const Char16* data)
-        {
-            return StringT::Create(data);
-        }
+        static String16* Create(const Char16* data);
 
-        static String16* Create(const Char16* data, const usize size)
-        {
-            return StringT::Create(data, size);
-        }
+        static String16* Create(const Char16* data, const usize size);
 
-#if _WINDOWS
-        static String16* Create(const wchar_t* data)
-        {
-            return Create(data, std::char_traits<wchar_t>::length(data));
-        }
+        #ifdef _WINDOWS
+        static String16* Create(const wchar_t* data);
 
-        static String16* Create(const wchar_t* data, const usize size)
-        {
-            return StringT::Create(reinterpret_cast<const char16_t*>(data), size);
-        }
+        static String16* Create(const wchar_t* data, const usize size);
 
         constexpr const wchar_t* c_str() const
         {
@@ -197,14 +170,13 @@ namespace Coplt
         {
             return std::wstring(c_str(), m_size);
         }
-#endif
+        #endif
 
-        FStr8or16 GetStr() const noexcept override
-        {
-            return FStr8or16(data(), size());
-        }
+        FStr8or16 GetStr() const noexcept override;
     };
 
+    extern String16* CreateString16(const wchar_t* data, usize size);
+
     struct CString final : StringForward<CString, char, char8_t, FString8>
     {
         constexpr explicit CString(StdString&& string) : StringForward(std::move(string))
@@ -216,13 +188,14 @@ namespace Coplt
         {
         }
 
-        FStr8or16 GetStr() const noexcept override
-        {
-            return FStr8or16(data(), size());
-        }
+        FStr8or16 GetStr() const noexcept override;
     };
 
-#if _WINDOWS
+    extern CString* CreateCString(std::string&& string);
+
+    extern CString* CreateCString(const char* data, usize size);
+
+    #ifdef _WINDOWS
     struct WString final : StringForward<WString, wchar_t, char16_t, FString16>
     {
         constexpr explicit WString(StdString&& string) : StringForward(std::move(string))
@@ -234,10 +207,7 @@ namespace Coplt
         {
         }
 
-        FStr8or16 GetStr() const noexcept override
-        {
-            return FStr8or16(data(), size());
-        }
+        FStr8or16 GetStr() const noexcept override;
     };
-#endif
+    #endif
 }
diff --git a/Coplt.Graphics.Native/D3d12/CMakeLists.txt b/Coplt.Graphics.Native/D3d12/CMakeLists.txt
index 3b0f42c..b1bc0c7 100644
--- a/Coplt.Graphics.Native/D3d12/CMakeLists.txt
+++ b/Coplt.Graphics.Native/D3d12/CMakeLists.txt
@@ -47,6 +47,7 @@ add_library(${target_name} SHARED
     FFI/Adapter.h
     Src/Adapter.h
     Src/Adapter.cc
+    Src/View.cc
 )
 set_target_properties(${target_name} PROPERTIES LINKER_LANGUAGE CXX)
 set_target_properties(${target_name} PROPERTIES OUTPUT_NAME "Coplt.Graphics.Native.D3d12")
diff --git a/Coplt.Graphics.Native/D3d12/Include/View.h b/Coplt.Graphics.Native/D3d12/Include/View.h
index 2ac5adb..556d4c1 100644
--- a/Coplt.Graphics.Native/D3d12/Include/View.h
+++ b/Coplt.Graphics.Native/D3d12/Include/View.h
@@ -3,6 +3,7 @@
 #include <variant>
 
 #include "../../Api/FFI/Resource.h"
+#include "../../Api/Include/Ptr.h"
 #include "../Src/Buffer.h"
 
 namespace Coplt
@@ -24,112 +25,35 @@ namespace Coplt
         Type m_type;
 
     public:
-        Type Type() const { return m_type; }
-        Rc<D3d12GpuBuffer>* Buffer() { return m_type == Type::Buffer ? std::addressof(m_buffer) : nullptr; }
-
-        ~View()
-        {
-            // ReSharper disable once CppDefaultCaseNotHandledInSwitchStatement
-            switch (m_type)
-            {
-            case Type::None:
-                return;
-            case Type::Buffer:
-                m_buffer.~Rc();
-                return;
-            }
-            std::unreachable();
-        }
-
-        View() : m_type(Type::None)
-        {
-        }
-
-        View(const View& other) : m_type(other.m_type)
-        {
-            switch (m_type)
-            {
-            case Type::None:
-                break;
-            case Type::Buffer:
-                new(std::addressof(m_buffer)) Rc(other.m_buffer);
-                break;
-            }
-        }
-
-        View(View&& other) noexcept : m_type(std::exchange(other.m_type, Type::None))
-        {
-            switch (m_type)
-            {
-            case Type::None:
-                break;
-            case Type::Buffer:
-                new(std::addressof(m_buffer)) Rc(std::move(other.m_buffer));
-                break;
-            }
-        }
-
-        View& operator=(const View& view) noexcept
-        {
-            this->~View();
-            new(this) View(view);
-            return *this;
-        }
-
-        View& operator=(View&& view) noexcept
-        {
-            this->~View();
-            new(this) View(std::forward<View>(view));
-            return *this;
-        }
-
-        View(const FView& view)
-        {
-            switch (view.Type)
-            {
-            case FViewType::None:
-                m_type = Type::None;
-                break;
-            case FViewType::Buffer:
-                m_type = Type::Buffer;
-                if (view.Buffer == nullptr) new(std::addressof(m_buffer)) Rc<D3d12GpuBuffer>();
-                const auto db = view.Buffer->QueryInterface<D3d12GpuBuffer>();
-                if (db == nullptr)
-                    COPLT_THROW("GpuBuffer from different backends.");
-                new(std::addressof(m_buffer)) Rc(Rc<D3d12GpuBuffer>::UnsafeClone(db));
-                break;
-            }
-        }
-
-        View& operator=(const FView& view)
-        {
-            this->~View();
-            new(this) View(view);
-            return *this;
-        }
-
-        View(const Rc<D3d12GpuBuffer>& buffer) : m_type(Type::Buffer)
-        {
-            new(std::addressof(m_buffer)) Rc(buffer);
-        }
-
-        View(Rc<D3d12GpuBuffer>&& buffer) : m_type(Type::Buffer)
-        {
-            new(std::addressof(m_buffer)) Rc(std::move(buffer));
-        }
-
-        View& operator=(const Rc<D3d12GpuBuffer>& buffer)
-        {
-            this->~View();
-            new(this) View(buffer);
-            return *this;
-        }
-
-        View& operator=(Rc<D3d12GpuBuffer>&& buffer)
-        {
-            this->~View();
-            new(this) View(std::forward<Rc<D3d12GpuBuffer>>(buffer));
-            return *this;
-        }
+        Type Type() const;
+        Rc<D3d12GpuBuffer>& Buffer() ;
+        const Rc<D3d12GpuBuffer>& Buffer() const ;
+
+        ~View();
+
+        View();
+
+        View(const View& other);
+        View(View&& other) noexcept;
+        View& operator=(const View& view) noexcept;
+        View& operator=(View&& view) noexcept;
+
+        View(const FView& view);
+        View& operator=(const FView& view);
+
+        View(const Rc<D3d12GpuBuffer>& buffer);
+        View(Rc<D3d12GpuBuffer>&& buffer);
+        View& operator=(const Rc<D3d12GpuBuffer>& buffer);
+        View& operator=(Rc<D3d12GpuBuffer>&& buffer);
+
+        void CreateDescriptor(
+            NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, CD3DX12_CPU_DESCRIPTOR_HANDLE handle, FShaderLayoutGroupView type
+        ) const;
+        static void CreateNullDescriptor(
+            NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, CD3DX12_CPU_DESCRIPTOR_HANDLE handle, FShaderLayoutGroupView view
+        );
+        void CreateBufferDescriptor(
+            NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, CD3DX12_CPU_DESCRIPTOR_HANDLE handle, FShaderLayoutGroupView type
+        ) const;
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Adapter.cc b/Coplt.Graphics.Native/D3d12/Src/Adapter.cc
index 40856c7..0be8f25 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Adapter.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Adapter.cc
@@ -1,8 +1,5 @@
 #include "Adapter.h"
 
-#include "directx/d3d12.h"
-#include "directx/d3dx12_check_feature_support.h"
-
 #include "../../Api/Include/Error.h"
 
 using namespace Coplt;
@@ -16,10 +13,9 @@ D3d12GpuAdapter::D3d12GpuAdapter(
     ComPtr<ID3D12Device> device{};
     chr | D3D12CreateDevice(m_adapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&device));
 
-    CD3DX12FeatureSupport feature_support{};
-    chr | feature_support.Init(device.Get());
+    chr | m_feature_support.Init(device.Get());
 
-    m_d3d_feature_level = static_cast<FD3dFeatureLevel>(feature_support.MaxSupportedFeatureLevel());
+    m_d3d_feature_level = static_cast<FD3dFeatureLevel>(m_feature_support.MaxSupportedFeatureLevel());
 
     DXGI_ADAPTER_DESC1 desc1{};
     chr | m_adapter->GetDesc1(&desc1);
@@ -32,7 +28,7 @@ D3d12GpuAdapter::D3d12GpuAdapter(
     {
         m_device_type = FDeviceType::Cpu;
     }
-    else if (feature_support.UMA())
+    else if (m_feature_support.UMA())
     {
         m_device_type = FDeviceType::IntegratedGpu;
     }
@@ -52,15 +48,15 @@ D3d12GpuAdapter::D3d12GpuAdapter(
     m_features.DescriptorHeap = true;
     m_features.ArrBindless = true;
 
-    m_features.ShaderModelLevel = static_cast<FShaderModelLevel>(feature_support.HighestShaderModel());
-    if (m_features.ShaderModelLevel >= FShaderModelLevel::SM_6_6)
+    m_features.ShaderModelLevel = static_cast<FShaderModelLevel>(m_feature_support.HighestShaderModel());
+    if (m_features.ShaderModelLevel >= FShaderModelLevel::SM_6_6 && m_feature_support.ResourceBindingTier() >= D3D12_RESOURCE_BINDING_TIER_3)
     {
         m_features.DynBindless = true;
     }
 
-    if (feature_support.RaytracingTier() >= D3D12_RAYTRACING_TIER_1_0) m_features.RayTracing = true;
-    if (feature_support.MeshShaderTier() >= D3D12_MESH_SHADER_TIER_1) m_features.MeshShader = true;
-    if (feature_support.EnhancedBarriersSupported()) m_features.EnhancedBarriers = true;
+    if (m_feature_support.RaytracingTier() >= D3D12_RAYTRACING_TIER_1_0) m_features.RayTracing = true;
+    if (m_feature_support.MeshShaderTier() >= D3D12_MESH_SHADER_TIER_1) m_features.MeshShader = true;
+    if (m_feature_support.EnhancedBarriersSupported()) m_features.EnhancedBarriers = true;
 }
 
 FResult D3d12GpuAdapter::CreateDevice(const FGpuDeviceCreateOptions& options, FGpuDevice** out) noexcept
diff --git a/Coplt.Graphics.Native/D3d12/Src/Adapter.h b/Coplt.Graphics.Native/D3d12/Src/Adapter.h
index 9f4f58b..acce76a 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Adapter.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Adapter.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <wrl/client.h>
+#include "directx/d3dx12.h"
 
 #include "Device.h"
 #include "../../Api/Include/Object.h"
@@ -14,6 +15,7 @@ namespace Coplt
         ComPtr<IDXGIAdapter1> m_adapter{};
         std::wstring m_name_string{};
         std::wstring m_driver_string{};
+        CD3DX12FeatureSupport m_feature_support{};
 
         explicit D3d12GpuAdapter(Rc<D3d12Instance>&& instance, ComPtr<IDXGIAdapter1>&& adapter);
 
diff --git a/Coplt.Graphics.Native/D3d12/Src/Binding.cc b/Coplt.Graphics.Native/D3d12/Src/Binding.cc
index 8fe6524..b668744 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Binding.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Binding.cc
@@ -3,9 +3,16 @@
 #include "Layout.h"
 #include "../../Api/Include/Error.h"
 #include "../FFI/Layout.h"
+#include "Queue.h"
+#include "../Include/GraphicsFormat.h"
 
 using namespace Coplt;
 
+namespace
+{
+    using TableScope = ID3d12ShaderLayout::TableScope;
+}
+
 D3d12ShaderBinding::D3d12ShaderBinding(
     Rc<D3d12GpuDevice>&& device, const FShaderBindingCreateOptions& options
 ) : m_device(std::move(device))
@@ -16,39 +23,49 @@ D3d12ShaderBinding::D3d12ShaderBinding(
     if (m_layout == nullptr)
         COPLT_THROW("Layout from different backends");
 
-    const auto item_metas = m_layout->GetItemMetas();
-    m_f_views = std::vector<FView>(item_metas.size(), {});
-    m_views = std::vector<View>(item_metas.size(), {});
-}
+    const auto defs = m_layout->GetItemDefines();
+    m_views = std::vector<View>(defs.size(), {});
 
-FResult D3d12ShaderBinding::SetName(const FStr8or16& name) noexcept
-{
-    return FResult::None();
-}
+    const auto classes = m_layout->GetTableGroups();
+    m_item_indexes = std::vector<std::vector<std::vector<u32>>>(classes.size(), {});
+    m_desc_heaps = std::vector<std::vector<Rc<DescriptorHeap>>>(classes.size(), {});
+    m_allocations = std::vector<std::vector<DescriptorAllocation>>(classes.size(), {});
+    for (size_t i = 0; i < classes.size(); ++i)
+    {
+        const auto& group = classes[i];
+        m_desc_heaps[i] = std::vector<Rc<DescriptorHeap>>(group.Metas.size(), {});
+        m_allocations[i] = std::vector<DescriptorAllocation>(group.Metas.size(), {});
+        auto& items = m_item_indexes[i] = std::vector<std::vector<u32>>(group.Metas.size(), {});
+        for (size_t j = 0; j < group.Metas.size(); ++j)
+        {
+            const auto& meta = group.Metas[j];
+            items[j].reserve(meta.Ranges.size());
+        }
+    }
 
-FView* D3d12ShaderBinding::GetViews(u32* out_size) noexcept
-{
-    *out_size = m_f_views.size();
-    return m_f_views.data();
+    const auto infos = m_layout->GetItemInfos();
+    for (size_t i = 0; i < infos.size(); ++i)
+    {
+        const auto& info = infos[i];
+        m_item_indexes[info.Class][info.Group].push_back(i);
+    }
 }
 
-FResult D3d12ShaderBinding::Set(const u32 count, const FShaderBindingBatchSet* bindings) noexcept
+FResult D3d12ShaderBinding::SetName(const FStr8or16& name) noexcept
 {
-    return feb([&]
-    {
-        Set(std::span(bindings, count));
-    });
+    return FResult::None();
 }
 
-void D3d12ShaderBinding::Set(const std::span<const FShaderBindingBatchSet> bindings)
+void D3d12ShaderBinding::Set(const std::span<const FBindItem> bindings)
 {
-    auto item_metas = m_layout->GetItemMetas();
+    auto infos = m_layout->GetItemInfos();
     auto item_defines = m_layout->GetItemDefines();
     for (const auto& [View, Index] : bindings)
     {
         if (Index >= m_views.size())
             COPLT_THROW("Index out of bounds");
         const auto& define = item_defines[Index];
+        const auto info = infos[Index];
         switch (View.Type)
         {
         case FViewType::None:
@@ -58,7 +75,78 @@ void D3d12ShaderBinding::Set(const std::span<const FShaderBindingBatchSet> bindi
                 COPLT_THROW_FMT("Binding index {} is not allowed to bind to buffer.", Index);
             break;
         }
-        m_f_views[Index] = View;
         m_views[Index] = View;
+        if (info.Place == FShaderLayoutItemPlace::Grouped)
+        {
+            m_changed_groups.Add((static_cast<u64>(info.Class) << 32) | static_cast<u64>(info.Group));
+        }
+    }
+}
+
+const Rc<ID3d12ShaderLayout>& D3d12ShaderBinding::Layout() noexcept
+{
+    return m_layout;
+}
+
+std::span<View> D3d12ShaderBinding::Views() noexcept
+{
+    return m_views;
+}
+
+bool D3d12ShaderBinding::Changed() noexcept
+{
+    return !m_changed_groups.IsEmpty();
+}
+
+const HashSet<u64>& D3d12ShaderBinding::ChangedGroups() noexcept
+{
+    return m_changed_groups;
+}
+
+std::span<const std::vector<Rc<DescriptorHeap>>> D3d12ShaderBinding::DescHeaps() noexcept
+{
+    return m_desc_heaps;
+}
+
+std::span<std::vector<DescriptorAllocation>> D3d12ShaderBinding::Allocations() noexcept
+{
+    return m_allocations;
+}
+
+void D3d12ShaderBinding::Update(NonNull<D3d12GpuQueue> queue)
+{
+    if (!Changed()) return;
+    const auto defs = m_layout->GetItemDefines();
+    const auto infos = m_layout->GetItemInfos();
+    const auto classes = m_layout->GetTableGroups();
+    for (const auto [c, g] : IterChangedGroups())
+    {
+        const auto& groups = classes[c];
+        const auto& meta = groups.Metas[g];
+        if (meta.Size == 0) continue;
+        auto& heap = m_desc_heaps[c][g];
+        if (heap == nullptr)
+            heap = new DescriptorHeap(
+                m_dx_device,
+                groups.Sampler ? D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER : D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+                meta.Size, false
+            );
+        const auto& indexes = m_item_indexes[c][g];
+        const auto handle_start = heap->GetLocalHandle();
+        const auto stride = heap->Stride();
+        for (const auto& i : indexes)
+        {
+            const auto& def = defs[i];
+            const auto& info = infos[i];
+            const auto& range = meta.Ranges[info.Index];
+            const CD3DX12_CPU_DESCRIPTOR_HANDLE handle(handle_start, static_cast<int>(range.OffsetInDescriptorsFromTableStart), stride);
+            const auto& view = m_views[i];
+            view.CreateDescriptor(m_dx_device.Get(), def, handle, meta.View);
+        }
     }
 }
+
+void D3d12ShaderBinding::ApplyChange()
+{
+    m_changed_groups.Clear();
+}
diff --git a/Coplt.Graphics.Native/D3d12/Src/Binding.h b/Coplt.Graphics.Native/D3d12/Src/Binding.h
index 4e1f625..a18d626 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Binding.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Binding.h
@@ -1,31 +1,71 @@
 #pragma once
 
+#include <ranges>
+
 #include "Device.h"
 #include "Layout.h"
 #include "../../Api/Include/Object.h"
+#include "../../Api/Include/Ptr.h"
 #include "../FFI/Binding.h"
 #include "../FFI/Layout.h"
 #include "../Include/View.h"
 
 namespace Coplt
 {
-    struct D3d12ShaderBinding final : Object<D3d12ShaderBinding, FD3d12ShaderBinding>
+    struct DescriptorHeap;
+    struct D3d12GpuQueue;
+    struct DescriptorAllocation;
+
+    COPLT_INTERFACE_DEFINE(ID3d12ShaderBinding, "84f2b3e2-bb16-4276-ba3f-5da54eda462d", FD3d12ShaderBinding)
+    {
+        virtual const Rc<ID3d12ShaderLayout>& Layout() noexcept = 0;
+        virtual std::span<View> Views() noexcept = 0;
+        virtual bool Changed() noexcept = 0;
+        virtual const HashSet<u64>& ChangedGroups() noexcept = 0;
+        virtual std::span<const std::vector<Rc<DescriptorHeap>>> DescHeaps() noexcept = 0;
+        virtual std::span<std::vector<DescriptorAllocation>> Allocations() noexcept = 0;
+
+        virtual void Set(std::span<const FBindItem> bindings) = 0;
+
+        // 更新更改过的表，但是不会消除更新
+        virtual void Update(NonNull<D3d12GpuQueue> queue) = 0;
+        // 实际消除更新
+        virtual void ApplyChange() = 0;
+
+        auto IterChangedGroups() noexcept
+        {
+            return ChangedGroups() | std::ranges::views::transform([](const u64 cg)
+            {
+                return std::pair{static_cast<u32>(cg >> 32), static_cast<u32>(cg & 0xFFFFFFFF)};
+            });
+        }
+    };
+
+    struct D3d12ShaderBinding final : Object<D3d12ShaderBinding, ID3d12ShaderBinding>
     {
         Rc<D3d12GpuDevice> m_device{};
         ComPtr<ID3D12Device2> m_dx_device{};
         Rc<ID3d12ShaderLayout> m_layout{};
-        std::vector<FView> m_f_views{};
         std::vector<View> m_views{};
-        std::vector<u32> m_changed{};
+        std::vector<std::vector<std::vector<u32>>> m_item_indexes{};
+        std::vector<std::vector<Rc<DescriptorHeap>>> m_desc_heaps{};
+        std::vector<std::vector<DescriptorAllocation>> m_allocations{};
+        HashSet<u64> m_changed_groups{};
 
         explicit D3d12ShaderBinding(Rc<D3d12GpuDevice>&& device, const FShaderBindingCreateOptions& options);
 
         FResult SetName(const FStr8or16& name) noexcept override;
 
-        FView* GetViews(u32* out_size) noexcept override;
+        void Set(std::span<const FBindItem> bindings) override;
 
-        FResult Set(u32 count, const FShaderBindingBatchSet* bindings) noexcept override;
+        const Rc<ID3d12ShaderLayout>& Layout() noexcept override;
+        std::span<View> Views() noexcept override;
+        bool Changed() noexcept override;
+        const HashSet<u64>& ChangedGroups() noexcept override;
+        std::span<const std::vector<Rc<DescriptorHeap>>> DescHeaps() noexcept override;
+        std::span<std::vector<DescriptorAllocation>> Allocations() noexcept override;
 
-        void Set(std::span<const FShaderBindingBatchSet> bindings);
+        void Update(NonNull<D3d12GpuQueue> queue) override;
+        void ApplyChange() override;
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Buffer.cc b/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
index fffc42f..42e1ecc 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Buffer.cc
@@ -15,10 +15,15 @@ D3d12GpuBuffer::D3d12GpuBuffer(Rc<D3d12GpuDevice>&& device, const FGpuBufferCrea
     m_stride = options.Stride;
     m_usage = options.Usage;
 
+    if (options.Usage == FBufferUsage::Raw)
+    {
+        m_size = (m_size + 255) / 256 * 256;
+    }
+
     if (HasAnyFlags(m_purpose, FResourcePurpose::DepthStencil | FResourcePurpose::ShadingRate))
         COPLT_THROW("Buffer does not support this purpose combination.");
 
-    m_desc = CD3DX12_RESOURCE_DESC1::Buffer(options.Size, D3D12_RESOURCE_FLAG_NONE);
+    m_desc = CD3DX12_RESOURCE_DESC1::Buffer(m_size, D3D12_RESOURCE_FLAG_NONE);
     if (HasAnyFlags(m_purpose, FResourcePurpose::UnorderedAccess))
         m_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 
diff --git a/Coplt.Graphics.Native/D3d12/Src/Command.cc b/Coplt.Graphics.Native/D3d12/Src/Command.cc
index d15126d..5d4fb4e 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Command.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Command.cc
@@ -1,6 +1,9 @@
 #include "Command.h"
 #include "../../Api/FFI/Command.h"
 
+#include <ranges>
+
+#include "Binding.h"
 #include "Context.h"
 #include "DescriptorManager.h"
 #include "fmt/format.h"
@@ -16,6 +19,7 @@
 #include "../ThirdParty/DirectXTK12/Src/d3dx12.h"
 
 #include "pix3.h"
+#include "../FFI/Binding.h"
 
 using namespace Coplt;
 
@@ -86,28 +90,60 @@ void D3d12CommandInterpreter::BarrierContext::BuildBarriers()
 void D3d12CommandInterpreter::Context::Reset()
 {
     Pipeline = nullptr;
-    D3dPipeline = nullptr;
+    Layout = nullptr;
+    GPipeline = nullptr;
+    Binding = nullptr;
+    PipelineChanged = false;
+    BindingChanged = false;
 }
 
-D3d12CommandInterpreter::D3d12CommandInterpreter(D3d12GpuQueue* queue) : m_queue(queue)
+D3d12CommandInterpreter::D3d12CommandInterpreter(const NonNull<D3d12GpuQueue>& queue) : m_queue(queue)
 {
 }
 
 void D3d12CommandInterpreter::Interpret(const FCommandSubmit& submit)
 {
+    m_descriptors = m_queue->m_frame_context->m_descriptors.get();
+    m_descriptors->InitFrame(submit.GrowCbvSrvUavBindingCapacity, submit.GrowSamplerBindingCapacity);
+
+    const auto desc_heaps = m_descriptors->GetDescriptorHeaps();
+    m_queue->m_cmd->SetDescriptorHeaps(2, desc_heaps.data());
+
     Translate(submit);
+
     Reset();
+    m_descriptors = nullptr;
 }
 
 void D3d12CommandInterpreter::Reset()
 {
     m_barrier_context.Reset();
     m_context.Reset();
+    m_bindings.Clear();
+}
+
+void D3d12CommandInterpreter::CheckSubmit(const FCommandSubmit& submit)
+{
+    NonNull(submit.Commands);
+    NonNull(submit.RenderCommands);
+    NonNull(submit.ComputeCommands);
+    NonNull(submit.Resources);
+    NonNull(submit.RenderInfos);
+    NonNull(submit.ComputeInfos);
+    NonNull(submit.ResolveInfos);
+    NonNull(submit.Rects);
+    NonNull(submit.Viewports);
+    NonNull(submit.MeshBuffers);
+    NonNull(submit.VertexBufferRanges);
+    NonNull(submit.BufferCopyRanges);
+    NonNull(submit.BindItems);
+    NonNull(submit.Barriers);
+    NonNull(submit.Str8);
+    NonNull(submit.Str16);
 }
 
 void D3d12CommandInterpreter::Translate(const FCommandSubmit& submit)
 {
-    const auto& cmd_pack = m_queue->m_cmd;
     const std::span command_items(submit.Commands, submit.CommandCount);
     for (u32 i = 0; i < command_items.size(); i++)
     {
@@ -136,7 +172,8 @@ void D3d12CommandInterpreter::Translate(const FCommandSubmit& submit)
             ClearDepthStencil(submit, i, item.ClearDepthStencil);
             continue;
         case FCommandType::Bind:
-            continue; // todo
+            Bind(submit, i, item.Bind);
+            continue;
         case FCommandType::BufferCopy:
             BufferCopy(submit, i, item.BufferCopy);
             continue;
@@ -144,7 +181,8 @@ void D3d12CommandInterpreter::Translate(const FCommandSubmit& submit)
             Render(submit, i, item.Render);
             continue;
         case FCommandType::Compute:
-            COPLT_THROW("TODO");
+            Compute(submit, i, item.Compute);
+            continue;
 
         // subcommands
         case FCommandType::SetPipeline:
@@ -325,6 +363,15 @@ void D3d12CommandInterpreter::BufferCopy(const FCommandSubmit& submit, u32 i, co
     }
 }
 
+void D3d12CommandInterpreter::Bind(const FCommandSubmit& submit, u32 i, const FCommandBind& cmd) const
+{
+    const auto binding = cmd.Binding->QueryInterface<ID3d12ShaderBinding>();
+    if (binding == nullptr)
+        COPLT_THROW_FMT("Binding from different backends at command {}", i);
+    const auto items = std::span(submit.BindItems + cmd.ItemsIndex, cmd.ItemCount);
+    binding->Set(items);
+}
+
 void D3d12CommandInterpreter::Render(const FCommandSubmit& submit, u32 i, const FCommandRender& cmd)
 {
     m_context.Reset();
@@ -422,7 +469,8 @@ void D3d12CommandInterpreter::Render(const FCommandSubmit& submit, u32 i, const
             SetPipeline(m_queue->m_cmd, item.SetPipeline.Pipeline, j);
             continue;
         case FCommandType::SetBinding:
-            continue; // todo
+            SetBinding(item.SetBinding.Binding, j);
+            continue;
         case FCommandType::SetViewportScissor:
             RenderSetViewportScissor(submit, j, item.SetViewportScissor);
             continue;
@@ -452,8 +500,9 @@ void D3d12CommandInterpreter::Render(const FCommandSubmit& submit, u32 i, const
     }
 }
 
-void D3d12CommandInterpreter::RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd) const
+void D3d12CommandInterpreter::RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd)
 {
+    SyncBinding();
     if (cmd.Indexed)
     {
         m_queue->m_cmd->DrawIndexedInstanced(cmd.VertexOrIndexCount, cmd.InstanceCount, cmd.FirstVertexOrIndex, cmd.VertexOffset, cmd.FirstInstance);
@@ -464,10 +513,11 @@ void D3d12CommandInterpreter::RenderDraw(const FCommandSubmit& submit, u32 i, co
     }
 }
 
-void D3d12CommandInterpreter::RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd) const
+void D3d12CommandInterpreter::RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd)
 {
     if (cmd.Type != FDispatchType::Mesh)
         COPLT_THROW_FMT("Render only supports DispatchMesh and does not support Dispatch for Compute at command {}", i);
+    SyncBinding();
     m_queue->m_cmd.m_list6->DispatchMesh(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
 }
 
@@ -507,16 +557,72 @@ void D3d12CommandInterpreter::RenderSetMeshBuffers(const FCommandSubmit& submit,
     cmd_pack->IASetVertexBuffers(cmd.VertexStartSlot, buffers.VertexBufferCount, views);
 }
 
-void D3d12CommandInterpreter::SetPipelineContext(FShaderPipeline* pipeline, const u32 i)
+void D3d12CommandInterpreter::Compute(const FCommandSubmit& submit, u32 i, const FCommandCompute& cmd)
+{
+    m_context.Reset();
+    const auto& _info = submit.ComputeInfos[cmd.InfoIndex];
+    const auto commands = std::span(submit.ComputeCommands + cmd.CommandStartIndex, cmd.CommandCount);
+    for (u32 j = 0; j < commands.size(); j++)
+    {
+        const auto& item = commands[j];
+        switch (item.Type)
+        {
+        case FCommandType::None:
+            continue;
+        case FCommandType::Label:
+            Label(submit, item.Label);
+            continue;
+        case FCommandType::BeginScope:
+            BeginScope(submit, item.BeginScope);
+            continue;
+        case FCommandType::EndScope:
+            EndScope(submit, item.EndScope);
+            continue;
+        case FCommandType::SetPipeline:
+            SetPipeline(m_queue->m_cmd, item.SetPipeline.Pipeline, j);
+            continue;
+        case FCommandType::SetBinding:
+            SetBinding(item.SetBinding.Binding, j);
+            continue;
+        case FCommandType::Dispatch:
+            ComputeDispatch(submit, j, item.Dispatch);
+            continue;
+        case FCommandType::SetViewportScissor:
+        case FCommandType::SetMeshBuffers:
+        case FCommandType::Draw:
+            COPLT_THROW("Compute commands cannot be placed in the render command list");
+        case FCommandType::Present:
+        case FCommandType::Barrier:
+        case FCommandType::ClearColor:
+        case FCommandType::ClearDepthStencil:
+        case FCommandType::Bind:
+        case FCommandType::BufferCopy:
+        case FCommandType::Render:
+        case FCommandType::Compute:
+            COPLT_THROW("Main commands cannot be placed in the sub command list");
+        }
+        COPLT_THROW_FMT("Unknown command type {}", static_cast<u32>(item.Type));
+    }
+}
+
+void D3d12CommandInterpreter::ComputeDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd)
+{
+    SyncBinding();
+    if (cmd.Type == FDispatchType::Mesh)
+        m_queue->m_cmd.m_list6->DispatchMesh(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
+    else
+        m_queue->m_cmd->Dispatch(cmd.GroupCountX, cmd.GroupCountY, cmd.GroupCountZ);
+}
+
+void D3d12CommandInterpreter::SetPipelineContext(NonNull<FShaderPipeline> pipeline, const u32 i)
 {
     if (pipeline == m_context.Pipeline) return;
-    m_context.Pipeline = pipeline;
-    m_context.D3dPipeline = pipeline->QueryInterface<FD3d12PipelineState>();
-    if (!m_context.D3dPipeline)
+    m_context.Pipeline = pipeline->QueryInterface<FD3d12PipelineState>();
+    if (!m_context.Pipeline)
     {
         COPLT_THROW_FMT(
             "Pipeline({:#x}) comes from different backends at cmd {}",
-            reinterpret_cast<size_t>(pipeline), i
+            static_cast<size_t>(pipeline), i
         );
     }
     m_context.Layout = pipeline->GetLayout()->QueryInterface<FD3d12ShaderLayout>();
@@ -530,10 +636,11 @@ void D3d12CommandInterpreter::SetPipelineContext(FShaderPipeline* pipeline, cons
         if (!m_context.GPipeline)
             COPLT_THROW("Pipeline from different backends or pipeline not a graphics pipeline");
     }
+    m_context.PipelineChanged = true;
 }
 
 void D3d12CommandInterpreter::SetPipeline(
-    const CmdListPack& cmd_pack, FShaderPipeline* pipeline, const u32 i
+    const CmdListPack& cmd_pack, NonNull<FShaderPipeline> pipeline, const u32 i
 )
 {
     if (pipeline == m_context.Pipeline) return;
@@ -549,15 +656,110 @@ void D3d12CommandInterpreter::SetPipeline(
         cmd_pack->IASetPrimitiveTopology(ToDx(states->Topology));
         cmd_pack->SetGraphicsRootSignature(static_cast<ID3D12RootSignature*>(m_context.Layout->GetRootSignaturePtr()));
     }
-    cmd_pack->SetPipelineState(static_cast<ID3D12PipelineState*>(m_context.D3dPipeline->GetPipelineStatePtr()));
+    cmd_pack->SetPipelineState(static_cast<ID3D12PipelineState*>(m_context.Pipeline->GetPipelineStatePtr()));
+}
+
+void D3d12CommandInterpreter::SetBinding(NonNull<FShaderBinding> binding, u32 i)
+{
+    if (binding == m_context.Binding) return;
+    m_context.Binding = binding->QueryInterface<ID3d12ShaderBinding>();
+    if (!m_context.Binding)
+        COPLT_THROW_FMT("Shader bindings from different backend at command {}", i);
+    m_context.BindingChanged = true;
+}
+
+void D3d12CommandInterpreter::SyncBinding()
+{
+    if (!(m_context.PipelineChanged || m_context.BindingChanged)) return;
+    if (const auto binding = m_context.Binding.get())
+    {
+        binding->Update(m_queue);
+        AllocAndUseBinding();
+        binding->ApplyChange();
+    }
+    m_context.PipelineChanged = false;
+    m_context.BindingChanged = false;
+}
+
+void D3d12CommandInterpreter::AllocAndUseBinding()
+{
+    const NonNull descriptors = m_descriptors;
+    const auto has_pixel = HasFlags(m_context.Pipeline->GetStages(), FShaderStageFlags::Pixel);
+    const auto& cmd_pack = m_queue->m_cmd;
+    const NonNull binding = m_context.Binding;
+    const auto first = m_bindings.Add(binding);
+    const auto layout = binding->Layout();
+    const auto classes = layout->GetTableGroups();
+    const auto heaps = binding->DescHeaps();
+    auto allocations = binding->Allocations();
+    if (first)
+    {
+        for (u32 c = 0; c < classes.size(); ++c)
+        {
+            const auto& groups = classes[c];
+            const auto da = groups.Sampler ? descriptors->SamplerHeap() : descriptors->ResourceHeap();
+            for (u32 g = 0; g < groups.Metas.size(); ++g)
+            {
+                const auto& heap = heaps[c][g];
+                if (!heap) continue;
+                auto& al = allocations[c][g];
+                AllocBindingGroup(groups, da, heap, al);
+            }
+        }
+    }
+    else
+    {
+        for (const auto [c, g] : binding->IterChangedGroups())
+        {
+            const auto& heap = heaps[c][g];
+            if (!heap) continue;
+            const auto& groups = classes[c];
+            const auto da = groups.Sampler ? descriptors->SamplerHeap() : descriptors->ResourceHeap();
+            auto& al = allocations[c][g];
+            AllocBindingGroup(groups, da, heap, al);
+        }
+    }
+    for (u32 i = 0; i < classes.size(); ++i)
+    {
+        const auto& groups = classes[i];
+        const auto& da = groups.Sampler ? m_descriptors->SamplerHeap() : m_descriptors->ResourceHeap();
+        for (u32 j = 0; j < groups.Metas.size(); ++j)
+        {
+            const auto& meta = groups.Metas[j];
+            const auto& al = allocations[i][j];
+            if (!al) continue;
+            const auto handle = da->GetRemoteHandle(al.Offset);
+            if (has_pixel) cmd_pack->SetGraphicsRootDescriptorTable(meta.RootIndex, handle);
+            else cmd_pack->SetComputeRootDescriptorTable(meta.RootIndex, handle);
+        }
+    }
+    // todo 其他 Root 项
+}
+
+void D3d12CommandInterpreter::AllocBindingGroup(
+    const ID3d12ShaderLayout::TableGroup& groups,
+    NonNull<DescriptorAllocator> da,
+    const Rc<DescriptorHeap>& heap,
+    DescriptorAllocation& al
+)
+{
+    if (groups.Scope == ID3d12ShaderLayout::TableScope::Material)
+    {
+        COPLT_THROW("TODO");
+    }
+    else
+    {
+        al = da->AllocateTransient(heap->Size());
+        da->Upload(al, heap);
+    }
 }
 
-ID3D12Resource* D3d12CommandInterpreter::GetResource(const FResourceMeta& meta)
+NonNull<ID3D12Resource> D3d12CommandInterpreter::GetResource(const FResourceMeta& meta)
 {
     return GetResource(meta.Output, meta.Type);
 }
 
-ID3D12Resource* D3d12CommandInterpreter::GetResource(FUnknown* object, FResourceRefType type)
+NonNull<ID3D12Resource> D3d12CommandInterpreter::GetResource(NonNull<FUnknown> object, FResourceRefType type)
 {
     switch (type)
     {
@@ -570,7 +772,7 @@ ID3D12Resource* D3d12CommandInterpreter::GetResource(FUnknown* object, FResource
                 COPLT_THROW("The memory may be corrupted");
             ID3D12Resource* ptr{};
             buffer->GetCurrentResourcePtr(&ptr).TryThrow();
-            return ptr;
+            return NonNull<ID3D12Resource>::Unchecked(ptr);
         }
     case FResourceRefType::Output:
         {
@@ -579,7 +781,7 @@ ID3D12Resource* D3d12CommandInterpreter::GetResource(FUnknown* object, FResource
                 COPLT_THROW("The memory may be corrupted");
             ID3D12Resource* ptr{};
             output->GetCurrentResourcePtr(&ptr).TryThrow();
-            return ptr;
+            return NonNull<ID3D12Resource>::Unchecked(ptr);
         }
     default:
         COPLT_THROW_FMT("Unknown resource ref type {}", static_cast<u8>(type));
diff --git a/Coplt.Graphics.Native/D3d12/Src/Command.h b/Coplt.Graphics.Native/D3d12/Src/Command.h
index 7993b5f..c57b1a5 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Command.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Command.h
@@ -2,6 +2,7 @@
 
 #include <variant>
 
+#include "Binding.h"
 #include "../../Api/FFI/States.h"
 #include "../../Api/FFI/Command.h"
 
@@ -10,6 +11,7 @@
 
 #include "CmdListPack.h"
 #include "../../Api/Include/ChunkedVector.h"
+#include "../../Api/Include/Ptr.h"
 
 namespace Coplt
 {
@@ -17,10 +19,12 @@ namespace Coplt
     struct FD3d12ShaderLayout;
     struct FD3d12PipelineState;
     struct D3d12GpuQueue;
+    struct DescriptorContext;
+    struct DescriptorAllocator;
 
     struct D3d12CommandInterpreter final
     {
-        D3d12GpuQueue* m_queue{};
+        NonNull<D3d12GpuQueue> m_queue;
 
     private:
         struct BarrierContext
@@ -42,31 +46,34 @@ namespace Coplt
 
         struct Context
         {
-            FShaderPipeline* Pipeline{};
-            FD3d12PipelineState* D3dPipeline{};
-            FD3d12ShaderLayout* Layout{};
+            Ptr<FD3d12PipelineState> Pipeline{};
+            Ptr<FD3d12ShaderLayout> Layout{};
             // 如果不是图形管线将不会设置
-            FD3d12GraphicsShaderPipeline* GPipeline{};
+            Ptr<FD3d12GraphicsShaderPipeline> GPipeline{};
+
+            Ptr<ID3d12ShaderBinding> Binding{};
+
+            bool PipelineChanged{};
+            bool BindingChanged{};
 
             void Reset();
         };
 
-        // std::vector<ResState> m_states{};
-        // std::vector<D3D12_RESOURCE_BARRIER> m_barriers{};
-        // std::vector<u32> m_barrier_resources{};
-        // std::vector<Item> m_items{};
-        // u32 m_last_barrier_index{};
         BarrierContext m_barrier_context{};
         Context m_context{};
+        Ptr<DescriptorContext> m_descriptors;
+        HashSet<ID3d12ShaderBinding*> m_bindings{};
 
     public:
-        explicit D3d12CommandInterpreter(D3d12GpuQueue* queue);
+        explicit D3d12CommandInterpreter(const NonNull<D3d12GpuQueue>& queue);
 
         void Interpret(const FCommandSubmit& submit);
 
     private:
         void Reset();
 
+        static void CheckSubmit(const FCommandSubmit& submit);
+
         void Translate(const FCommandSubmit& submit);
 
         void Label(const FCommandSubmit& submit, const FCommandLabel& cmd) const;
@@ -79,21 +86,31 @@ namespace Coplt
         void ClearColor(const FCommandSubmit& submit, u32 i, const FCommandClearColor& cmd) const;
         void ClearDepthStencil(const FCommandSubmit& submit, u32 i, const FCommandClearDepthStencil& cmd) const;
         void BufferCopy(const FCommandSubmit& submit, u32 i, const FCommandBufferCopy& cmd) const;
+        void Bind(const FCommandSubmit& submit, u32 i, const FCommandBind& cmd) const;
         void Render(const FCommandSubmit& submit, u32 i, const FCommandRender& cmd);
-        void RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd) const;
-        void RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd) const;
+        void RenderDraw(const FCommandSubmit& submit, u32 i, const FCommandDraw& cmd);
+        void RenderDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd);
         void RenderSetViewportScissor(const FCommandSubmit& submit, u32 i, const FCommandSetViewportScissor& cmd) const;
         void RenderSetMeshBuffers(const FCommandSubmit& submit, u32 i, const FCommandSetMeshBuffers& cmd) const;
+        void Compute(const FCommandSubmit& submit, u32 i, const FCommandCompute& cmd);
+        void ComputeDispatch(const FCommandSubmit& submit, u32 i, const FCommandDispatch& cmd);
 
-        void SetPipelineContext(
-            FShaderPipeline* pipeline, u32 i
-        );
-        void SetPipeline(
-            const CmdListPack& cmd_pack, FShaderPipeline* pipeline, u32 i
+        void SetPipelineContext(NonNull<FShaderPipeline> pipeline, u32 i);
+        void SetPipeline(const CmdListPack& cmd_pack, NonNull<FShaderPipeline> pipeline, u32 i);
+
+        void SetBinding(NonNull<FShaderBinding> binding, u32 i);
+
+        void SyncBinding();
+        void AllocAndUseBinding();
+        void AllocBindingGroup(
+            const ID3d12ShaderLayout::TableGroup& groups,
+            NonNull<DescriptorAllocator> da,
+            const Rc<DescriptorHeap>& heap,
+            DescriptorAllocation& al
         );
 
-        static ID3D12Resource* GetResource(const FResourceMeta& meta);
-        static ID3D12Resource* GetResource(FUnknown* object, FResourceRefType type);
+        static NonNull<ID3D12Resource> GetResource(const FResourceMeta& meta);
+        static NonNull<ID3D12Resource> GetResource(NonNull<FUnknown> object, FResourceRefType type);
         static D3D12_CPU_DESCRIPTOR_HANDLE GetRtv(const FResourceMeta& meta);
         static D3D12_CPU_DESCRIPTOR_HANDLE GetDsv(const FResourceMeta& meta);
     };
diff --git a/Coplt.Graphics.Native/D3d12/Src/Context.cc b/Coplt.Graphics.Native/D3d12/Src/Context.cc
index 7e0acf1..b4821ea 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Context.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Context.cc
@@ -11,6 +11,9 @@ D3d12FrameContext::D3d12FrameContext(Rc<D3d12GpuQueue>&& queue) : m_queue(std::m
 {
     m_device = m_queue->m_device;
     m_dx_device = m_queue->m_dx_device;
+
+    m_descriptors = new DescriptorContext(m_dx_device);
+
     m_upload_buffer = FList<FUploadBufferBlock>(m_device->m_instance->m_allocator.get());
 
     chr | m_dx_device->CreateCommandAllocator(
diff --git a/Coplt.Graphics.Native/D3d12/Src/Context.h b/Coplt.Graphics.Native/D3d12/Src/Context.h
index 34baee8..d3bf8cc 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Context.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Context.h
@@ -18,6 +18,7 @@ namespace Coplt
         ComPtr<ID3D12Device2> m_dx_device{};
         Rc<D3d12GpuQueue> m_queue{};
         ComPtr<ID3D12CommandAllocator> m_command_allocator{};
+        Rc<DescriptorContext> m_descriptors{};
         std::vector<BufferPack> m_upload_buffers{};
         usize m_cur_upload_buffer_index{};
         usize m_cur_upload_buffer_size{};
diff --git a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc
index 7d1ed40..bdc4dff 100644
--- a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.cc
@@ -2,34 +2,147 @@
 
 using namespace Coplt;
 
-CpuDescriptorSet::CpuDescriptorSet(
-    ComPtr<ID3D12Device2> device, const D3D12_DESCRIPTOR_HEAP_TYPE type, const u32 init_cap
-) : m_device(std::move(device)), m_type(type), m_cap(init_cap)
+DescriptorHeap::DescriptorHeap(ComPtr<ID3D12Device2> device, const D3D12_DESCRIPTOR_HEAP_TYPE type, u32 size, bool gpu)
+    : m_device(std::move(device)), m_type(type), m_size(size), m_gpu(gpu)
 {
     D3D12_DESCRIPTOR_HEAP_DESC desc{};
     desc.Type = type;
-    desc.NumDescriptors = init_cap;
+    desc.NumDescriptors = size;
+    if (gpu) desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
     chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_heap));
+    m_stride = m_device->GetDescriptorHandleIncrementSize(type);
 }
 
-GpuDescriptorSet::GpuDescriptorSet(
-    ComPtr<ID3D12Device2> device, const D3D12_DESCRIPTOR_HEAP_TYPE type, const u32 init_cap
-) : m_device(std::move(device)), m_type(type), m_cap(init_cap)
+const ComPtr<ID3D12DescriptorHeap>& DescriptorHeap::Heap() const
 {
-    D3D12_DESCRIPTOR_HEAP_DESC desc{};
-    desc.Type = type;
-    desc.NumDescriptors = init_cap;
-    chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_Cpu_heap));
-    desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
-    chr | m_device->CreateDescriptorHeap(&desc, IID_PPV_ARGS(&m_Gpu_heap));
+    return m_heap;
+}
+
+D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeap::Type() const
+{
+    return m_type;
+}
+
+u32 DescriptorHeap::Stride() const
+{
+    return m_stride;
 }
 
-DescriptorManager::DescriptorManager(D3d12GpuDevice* device) : m_device(device)
+bool DescriptorHeap::IsRemote() const
 {
-    m_dx_device = m_device->m_device;
+    return m_gpu;
+}
+
+u32 DescriptorHeap::Size() const
+{
+    return m_size;
+}
 
-    m_rtv_set = box<CpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, RtvDsvInitCap);
-    m_dsv_set = box<CpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, RtvDsvInitCap);
-    m_cbv_srv_uav_set = box<GpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, CbvSrvUavInitCap);
-    m_sampler_set = box<GpuDescriptorSet>(m_dx_device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, SamplerInitCap);
+CD3DX12_CPU_DESCRIPTOR_HANDLE DescriptorHeap::GetLocalHandle(const u32 offset) const
+{
+    return CD3DX12_CPU_DESCRIPTOR_HANDLE(m_heap->GetCPUDescriptorHandleForHeapStart(), static_cast<i32>(offset), m_stride);
+}
+
+CD3DX12_GPU_DESCRIPTOR_HANDLE DescriptorHeap::GetRemoteHandle(const u32 offset) const
+{
+    return CD3DX12_GPU_DESCRIPTOR_HANDLE(m_heap->GetGPUDescriptorHandleForHeapStart(), static_cast<i32>(offset), m_stride);
+}
+
+DescriptorAllocator::DescriptorAllocator(const ComPtr<ID3D12Device2>& device, const D3D12_DESCRIPTOR_HEAP_TYPE type)
+    : m_device(device), m_type(type), m_stride(device->GetDescriptorHandleIncrementSize(type))
+{
+}
+
+const Rc<DescriptorHeap>& DescriptorAllocator::Heap() const
+{
+    return m_heap;
+}
+
+D3D12_DESCRIPTOR_HEAP_TYPE DescriptorAllocator::Type() const
+{
+    return m_type;
+}
+
+u32 DescriptorAllocator::Stride() const
+{
+    return m_stride;
+}
+
+CD3DX12_CPU_DESCRIPTOR_HANDLE DescriptorAllocator::GetLocalHandle(const u32 offset) const
+{
+    return m_heap->GetLocalHandle(offset);
+}
+
+CD3DX12_GPU_DESCRIPTOR_HANDLE DescriptorAllocator::GetRemoteHandle(const u32 offset) const
+{
+    return m_heap->GetRemoteHandle(offset);
+}
+
+void DescriptorAllocator::InitFrame(const u32 TransientCapacity)
+{
+    if (m_heap == nullptr || m_heap->Size() < TransientCapacity)
+    {
+        m_heap = new DescriptorHeap(m_device, m_type, std::bit_ceil(std::max(8u, TransientCapacity)), true);
+    }
+    m_transient_offset = 0;
+}
+
+DescriptorAllocation DescriptorAllocator::AllocateTransient(const u32 Size)
+{
+    if (!m_heap)
+        COPLT_THROW("Descriptor heap is null");
+    const auto offset = m_transient_offset;
+    const auto new_offset = offset + Size;
+    if (new_offset > m_heap->Size())
+        COPLT_THROW("Out of descriptor heap");
+    m_transient_offset = new_offset;
+    return {.Offset = offset, .Size = Size};
+}
+
+void DescriptorAllocator::Upload(const DescriptorAllocation& al, const Rc<DescriptorHeap>& heap, u32 offset) const
+{
+    if (al.Size == 0) return;
+    m_device->CopyDescriptorsSimple(
+        al.Size,
+        GetLocalHandle(al.Offset),
+        heap->GetLocalHandle(offset),
+        m_type
+    );
+}
+
+DescriptorContext::DescriptorContext(const ComPtr<ID3D12Device2>& device) : m_device(device)
+{
+    m_resource = new DescriptorAllocator(m_device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+    m_sampler = new DescriptorAllocator(m_device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+}
+
+NonNull<DescriptorAllocator> DescriptorContext::ResourceHeap() const
+{
+    if (!m_in_frame) [[unlikely]]
+        COPLT_THROW("Frame not started");
+    return m_resource.get();
+}
+
+NonNull<DescriptorAllocator> DescriptorContext::SamplerHeap() const
+{
+    if (!m_in_frame) [[unlikely]]
+        COPLT_THROW("Frame not started");
+    return m_sampler.get();
+}
+
+void DescriptorContext::InitFrame(const u32 ResourceCap, const u32 SamplerCap)
+{
+    m_resource->InitFrame(ResourceCap);
+    m_sampler->InitFrame(SamplerCap);
+    m_in_frame = true;
+}
+
+void DescriptorContext::EndFrame()
+{
+    m_in_frame = false;
+}
+
+std::array<ID3D12DescriptorHeap*, 2> DescriptorContext::GetDescriptorHeaps() const
+{
+    return {m_resource->Heap()->Heap().Get(), m_sampler->Heap()->Heap().Get()};
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h
index 0a59129..1582a16 100644
--- a/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h
+++ b/Coplt.Graphics.Native/D3d12/Src/DescriptorManager.h
@@ -1,52 +1,94 @@
 #pragma once
 
+#include "directx/d3dx12.h"
+
+#include <array>
 #include <concurrent_queue.h>
+#include <mutex>
+#include <bit>
 
 #include "Device.h"
+#include "../../Api/Include/Ptr.h"
 
 namespace Coplt
 {
-    struct CpuDescriptorSet
+    struct DescriptorHeap final : Object<DescriptorHeap, FUnknown>
     {
+    private:
         ComPtr<ID3D12Device2> m_device{};
-
-        D3D12_DESCRIPTOR_HEAP_TYPE m_type{};
         ComPtr<ID3D12DescriptorHeap> m_heap{};
+        D3D12_DESCRIPTOR_HEAP_TYPE m_type{};
+        u32 m_stride{};
+        u32 m_size{};
+        bool m_gpu{};
+
+    public:
+        explicit DescriptorHeap(ComPtr<ID3D12Device2> device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 size, bool gpu);
 
-        u32 m_used{};
-        u32 m_cap{};
+        const ComPtr<ID3D12DescriptorHeap>& Heap() const;
 
-        explicit CpuDescriptorSet(ComPtr<ID3D12Device2> device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 init_cap);
+        D3D12_DESCRIPTOR_HEAP_TYPE Type() const;
+        u32 Stride() const;
+        bool IsRemote() const;
+
+        u32 Size() const;
+
+        CD3DX12_CPU_DESCRIPTOR_HANDLE GetLocalHandle(u32 offset = 0) const;
+        CD3DX12_GPU_DESCRIPTOR_HANDLE GetRemoteHandle(u32 offset = 0) const;
     };
 
-    struct GpuDescriptorSet
+    struct DescriptorAllocation
     {
+        u32 Offset{COPLT_U32_MAX};
+        u32 Size{};
+        // todo Persist;
+
+        operator bool() const { return Offset != COPLT_U32_MAX; }
+    };
+
+    struct DescriptorAllocator final : Object<DescriptorAllocator, FUnknown>
+    {
+    private:
         ComPtr<ID3D12Device2> m_device{};
+        Rc<DescriptorHeap> m_heap{};
+        D3D12_DESCRIPTOR_HEAP_TYPE const m_type{};
+        u32 const m_stride{};
+        u32 m_transient_offset{};
 
-        D3D12_DESCRIPTOR_HEAP_TYPE m_type{};
-        ComPtr<ID3D12DescriptorHeap> m_Cpu_heap{};
-        ComPtr<ID3D12DescriptorHeap> m_Gpu_heap{};
+    public:
+        explicit DescriptorAllocator(const ComPtr<ID3D12Device2>& device, D3D12_DESCRIPTOR_HEAP_TYPE type);
+
+        const Rc<DescriptorHeap>& Heap() const;
 
-        u32 m_used{};
-        u32 m_cap{};
+        D3D12_DESCRIPTOR_HEAP_TYPE Type() const;
+        u32 Stride() const;
 
-        explicit GpuDescriptorSet(ComPtr<ID3D12Device2> device, D3D12_DESCRIPTOR_HEAP_TYPE type, u32 init_cap);
+        CD3DX12_CPU_DESCRIPTOR_HANDLE GetLocalHandle(u32 offset = 0) const;
+        CD3DX12_GPU_DESCRIPTOR_HANDLE GetRemoteHandle(u32 offset = 0) const;
+
+        void InitFrame(u32 TransientCapacity);
+
+        DescriptorAllocation AllocateTransient(u32 Size);
+        void Upload(const DescriptorAllocation& al, const Rc<DescriptorHeap>& heap, u32 offset = 0) const;
     };
 
-    struct DescriptorManager final
+    struct DescriptorContext final : Object<DescriptorContext, FUnknown>
     {
-        constexpr static u32 RtvDsvInitCap = 128;
-        constexpr static u32 SamplerInitCap = 128;
-        constexpr static u32 CbvSrvUavInitCap = 1024;
+    private:
+        ComPtr<ID3D12Device2> m_device{};
+        Rc<DescriptorAllocator> m_resource{};
+        Rc<DescriptorAllocator> m_sampler{};
+        bool m_in_frame{};
+
+    public:
+        explicit DescriptorContext(const ComPtr<ID3D12Device2>& device);
 
-        D3d12GpuDevice* m_device;
-        ComPtr<ID3D12Device2> m_dx_device{};
+        NonNull<DescriptorAllocator> ResourceHeap() const;
+        NonNull<DescriptorAllocator> SamplerHeap() const;
 
-        Box<CpuDescriptorSet> m_rtv_set{};
-        Box<CpuDescriptorSet> m_dsv_set{};
-        Box<GpuDescriptorSet> m_cbv_srv_uav_set{};
-        Box<GpuDescriptorSet> m_sampler_set{};
+        void InitFrame(u32 ResourceCap, u32 SamplerCap);
+        void EndFrame();
 
-        explicit DescriptorManager(D3d12GpuDevice* device);
+        std::array<ID3D12DescriptorHeap*, 2> GetDescriptorHeaps() const;
     };
 }
diff --git a/Coplt.Graphics.Native/D3d12/Src/Device.cc b/Coplt.Graphics.Native/D3d12/Src/Device.cc
index 8e54792..131778f 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Device.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Device.cc
@@ -76,8 +76,6 @@ D3d12GpuDevice::D3d12GpuDevice(Rc<D3d12GpuAdapter>&& adapter, const FGpuDeviceCr
     }
 
     chr | m_device->QueryInterface(IID_PPV_ARGS(&m_device0));
-
-    m_descriptor_manager = box<DescriptorManager>(this);
 }
 
 D3d12GpuDevice::~D3d12GpuDevice()
diff --git a/Coplt.Graphics.Native/D3d12/Src/Device.h b/Coplt.Graphics.Native/D3d12/Src/Device.h
index e7bd340..9de96a5 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Device.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Device.h
@@ -11,7 +11,6 @@
 namespace Coplt
 {
     struct D3d12GpuAdapter;
-    struct DescriptorManager;
     struct D3d12ShaderLayout;
     struct D3d12MeshLayout;
 
@@ -25,7 +24,6 @@ namespace Coplt
         ComPtr<ID3D12Device> m_device0{};
         ComPtr<ID3D12InfoQueue1> m_info_queue{};
         ComPtr<D3D12MA::Allocator> m_gpu_allocator{};
-        Box<DescriptorManager> m_descriptor_manager{};
         Box<EmptyLayouts> m_empty_layouts{};
         Rc<D3d12MeshLayout> m_empty_mesh_layout{};
         DWORD m_callback_cookie{};
diff --git a/Coplt.Graphics.Native/D3d12/Src/Layout.cc b/Coplt.Graphics.Native/D3d12/Src/Layout.cc
index 31b0793..bbc542b 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Layout.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Layout.cc
@@ -1,9 +1,82 @@
 #include "Layout.h"
 
+#include <ranges>
+
 #include "../Include/ShaderVisibility.h"
 
 using namespace Coplt;
 
+namespace
+{
+    struct TableKey
+    {
+        FShaderStage Stage{};
+        FShaderLayoutGroupView View{};
+
+        TableKey() = default;
+
+        explicit TableKey(const FShaderStage Stage, const FShaderLayoutGroupView View) : Stage(Stage), View(View)
+        {
+        }
+
+        struct Hasher
+        {
+            size_t operator()(const TableKey& value) const
+            {
+                return std::hash<u16>{}(static_cast<u16>(value.Stage) | (static_cast<u16>(value.View) << 8));
+            }
+        };
+
+        struct Eq
+        {
+            bool operator()(const TableKey& lhs, const TableKey& rhs) const
+            {
+                return lhs.Stage == rhs.Stage && lhs.View == rhs.View;
+            }
+        };
+    };
+
+    using TableMeta = ID3d12ShaderLayout::TableMeta;
+    using TableScope = ID3d12ShaderLayout::TableScope;
+
+    struct TableGroupKey
+    {
+        TableScope Scope{};
+        bool Sampler{};
+
+        TableGroupKey() = default;
+
+        explicit TableGroupKey(const TableScope Scope, const bool Sampler) : Scope(Scope), Sampler(Sampler)
+        {
+        }
+
+        struct Hasher
+        {
+            size_t operator()(const TableGroupKey& value) const
+            {
+                return std::hash<u16>{}(static_cast<u16>(value.Scope) | (static_cast<u16>(value.Sampler) << 8));
+            }
+        };
+
+        struct Eq
+        {
+            bool operator()(const TableGroupKey& lhs, const TableGroupKey& rhs) const
+            {
+                return lhs.Scope == rhs.Scope && lhs.Sampler == rhs.Sampler;
+            }
+        };
+    };
+
+    struct TableDefine
+    {
+        u8 Index{};
+        u32 IndexInc{};
+        HashMap<TableKey, TableMeta, TableKey::Hasher, TableKey::Eq> Map{};
+    };
+
+    using TmpTableGroupMap = HashMap<TableGroupKey, TableDefine, TableGroupKey::Hasher, TableGroupKey::Eq>;
+}
+
 D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderLayoutCreateOptions& options)
     : m_device(std::move(device))
 {
@@ -12,12 +85,12 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
     Flags = options.Flags;
 
     m_layout_item_defines = std::vector(options.Items, options.Items + options.Count);
-    m_item_metas = std::vector<ItemMeta>(options.Count, {});
+    m_item_infos = std::vector<FShaderLayoutItemInfo>(options.Count, {});
 
     std::vector<D3D12_ROOT_PARAMETER1> root_parameters{};
 
-    HashMap<TableKey, TableMeta, TableKey::Hasher, TableKey::Eq> tables[2]{};
-    u32 table_index[2]{};
+    TmpTableGroupMap tables{};
+    u8 TableGroupIndexInc{};
 
     for (u32 i = 0; i < m_layout_item_defines.size(); i++)
     {
@@ -34,7 +107,10 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
             param.Constants.RegisterSpace = item.Space;
             param.Constants.Num32BitValues = std::max(1u, item.CountOrIndex);
             param.ShaderVisibility = ToDxVisibility(item.Stage);
-            m_item_metas[i] = ItemMeta{.Index = static_cast<u32>(root_parameters.size()), .Type = ItemType::Const};
+            m_item_infos[i] = FShaderLayoutItemInfo{
+                .Index = static_cast<u32>(root_parameters.size()),
+                .Place = FShaderLayoutItemPlace::Const,
+            };
             root_parameters.push_back(param);
             continue;
         }
@@ -51,7 +127,7 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
             table_scope = TableScope::Material;
             goto DefineDescriptorTable;
         case FShaderLayoutItemUsage::Instant:
-            if (item.CountOrIndex > 1)
+            if (item.CountOrIndex > 1 || !IsBuffer(item.Type))
             {
                 table_scope = TableScope::Common;
                 goto DefineDescriptorTable;
@@ -86,70 +162,96 @@ D3d12ShaderLayout::D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderL
             param.Descriptor.RegisterSpace = item.Space;
             param.Descriptor.Flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE;
             param.ShaderVisibility = ToDxVisibility(item.Stage);
-            m_item_metas[i] = ItemMeta{.Index = static_cast<u32>(root_parameters.size()), .Type = ItemType::Direct};
+            m_item_infos[i] = FShaderLayoutItemInfo{
+                .Index = static_cast<u32>(root_parameters.size()),
+                .Place = FShaderLayoutItemPlace::Direct,
+            };
             root_parameters.push_back(param);
             continue;
         }
     DefineDescriptorTable:
         {
-            auto& table = tables[static_cast<u8>(table_scope)];
-            RangeType range_type{};
+            auto& table = tables.GetOrAdd(TableGroupKey(table_scope, item.View == FShaderLayoutItemView::Sampler), [&](auto& p)
+            {
+                p = TableDefine{.Index = TableGroupIndexInc++};
+            });
+            FShaderLayoutGroupView group_view{};
             D3D12_DESCRIPTOR_RANGE1 range{};
             switch (item.View)
             {
             case FShaderLayoutItemView::Cbv:
                 range.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV;
-                range_type = RangeType::Cbv;
+                group_view = FShaderLayoutGroupView::Cbv;
                 break;
             case FShaderLayoutItemView::Srv:
                 range.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV;
-                range_type = RangeType::Srv;
+                group_view = FShaderLayoutGroupView::Srv;
                 break;
             case FShaderLayoutItemView::Uav:
                 range.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_UAV;
-                range_type = RangeType::Uav;
+                group_view = FShaderLayoutGroupView::Uav;
                 break;
             case FShaderLayoutItemView::Sampler:
                 range.RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER;
-                range_type = RangeType::Sampler;
+                group_view = FShaderLayoutGroupView::Sampler;
                 break;
             default:
                 COPLT_THROW_FMT("Unknown shader layout item type {}", static_cast<u32>(item.Type));
             }
-            auto& meta = table.GetOrAdd(TableKey(item.Stage, range_type), [&](auto& p)
+            auto& meta = table.Map.GetOrAdd(TableKey(item.Stage, group_view), [&](auto& p)
             {
-                p = TableMeta(table_index[static_cast<u8>(table_scope)]++, item.Stage, range_type);
+                p = TableMeta(table.IndexInc++, item.Stage, group_view);
             });
             range.NumDescriptors = std::max(1u, item.CountOrIndex);
             range.BaseShaderRegister = item.Slot;
             range.RegisterSpace = item.Space;
-            range.OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND;
-            m_item_metas[i] = ItemMeta{
-                .Index = static_cast<u32>(meta.ranges.size()), .Table = table_scope,
-                .Type = ItemType::InTable, .RangeType = range_type
+            range.OffsetInDescriptorsFromTableStart = meta.Size;
+            // range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
+            m_item_infos[i] = FShaderLayoutItemInfo{
+                .Index = static_cast<u32>(meta.Ranges.size()),
+                .Class = table.Index,
+                .Group = meta.Index,
+                .Place = FShaderLayoutItemPlace::Grouped,
             };
-            meta.ranges.push_back(range);
+            meta.Ranges.push_back(range);
+            meta.Size += range.NumDescriptors;
             continue;
         }
     }
 
-    for (u8 ts = 0; ts < 2; ++ts)
+    m_table_groups = std::vector<TableGroup>(tables.Count(), {});
+    m_group_classes = std::vector<FShaderLayoutGroupClass>(tables.Count(), {});
+    for (auto& [key, table] : tables)
     {
-        auto& table = tables[ts];
-        auto& table_metas = m_table_metas[ts];
-        table_metas = std::vector<TableMeta>(table.Count(), {});
-        for (auto& pair : table)
+        auto& table_groups = m_table_groups[table.Index];
+        auto& group_class = m_group_classes[table.Index];
+        table_groups = TableGroup{
+            .Metas = std::vector<TableMeta>(table.Map.Count(), {}),
+            .Infos = std::vector<FShaderLayoutGroupInfo>(table.Map.Count(), {}),
+            .Scope = key.Scope, .Sampler = key.Sampler
+        };
+        group_class = FShaderLayoutGroupClass{
+            .Infos = table_groups.Infos.data(),
+            .Size = static_cast<u32>(table_groups.Metas.size()),
+            .Sampler = key.Sampler
+        };
+        for (auto& item : table.Map | std::views::values)
         {
             D3D12_ROOT_PARAMETER1 param{};
             param.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
 
-            auto& meta = table_metas[pair.second.Index];
-            meta = std::move(pair.second);
+            auto& meta = table_groups.Metas[item.Index];
+            auto& info = table_groups.Infos[item.Index];
+            meta = std::move(item);
             meta.RootIndex = root_parameters.size();
+            info.Index = meta.RootIndex;
+            info.Size = meta.Ranges.size();
+            info.Stage = meta.Stage;
+            info.View = meta.View;
 
             param.ShaderVisibility = ToDxVisibility(meta.Stage);
-            param.DescriptorTable.NumDescriptorRanges = meta.ranges.size();
-            param.DescriptorTable.pDescriptorRanges = meta.ranges.data();
+            param.DescriptorTable.NumDescriptorRanges = meta.Ranges.size();
+            param.DescriptorTable.pDescriptorRanges = meta.Ranges.data();
 
             root_parameters.push_back(param);
         }
@@ -213,14 +315,21 @@ const FShaderLayoutItemDefine* D3d12ShaderLayout::GetItemDefines(u32* out_count)
     return m_layout_item_defines.data();
 }
 
-std::span<ID3d12ShaderLayout::ItemMeta> D3d12ShaderLayout::GetItemMetas() noexcept
+const FShaderLayoutItemInfo* D3d12ShaderLayout::GetItemInfos(u32* out_count) noexcept
+{
+    *out_count = static_cast<u32>(m_item_infos.size());
+    return m_item_infos.data();
+}
+
+const FShaderLayoutGroupClass* D3d12ShaderLayout::GetGroupClasses(u32* out_count) noexcept
 {
-    return m_item_metas;
+    *out_count = static_cast<u32>(m_group_classes.size());
+    return m_group_classes.data();
 }
 
-std::array<std::span<ID3d12ShaderLayout::TableMeta>, 2> D3d12ShaderLayout::GetTableMetas() noexcept
+std::span<ID3d12ShaderLayout::TableGroup> D3d12ShaderLayout::GetTableGroups() noexcept
 {
-    return std::array<std::span<TableMeta>, 2>{m_table_metas[0], m_table_metas[1]};
+    return m_table_groups;
 }
 
 D3d12ShaderInputLayout::D3d12ShaderInputLayout(
diff --git a/Coplt.Graphics.Native/D3d12/Src/Layout.h b/Coplt.Graphics.Native/D3d12/Src/Layout.h
index 7b5e2fd..470110e 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Layout.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Layout.h
@@ -13,85 +13,40 @@ namespace Coplt
 {
     COPLT_INTERFACE_DEFINE(ID3d12ShaderLayout, "d8cea40e-7b0c-4a5f-98a9-88fd3abf9ddc", FD3d12ShaderLayout)
     {
-        enum class ItemType : u8
-        {
-            None,
-            Const,
-            Direct,
-            InTable,
-            StaticSampler,
-        };
-
         enum class TableScope : u8
         {
             Common,
             Material,
         };
 
-        enum class RangeType : u8
-        {
-            Cbv,
-            Srv,
-            Uav,
-            Sampler,
-        };
-
-        struct TableKey
-        {
-            FShaderStage Stage{};
-            RangeType Type{};
-
-            TableKey() = default;
-
-            explicit TableKey(const FShaderStage Stage, const RangeType Type) : Stage(Stage), Type(Type)
-            {
-            }
-
-            struct Hasher
-            {
-                size_t operator()(const TableKey& value) const
-                {
-                    return std::hash<u16>{}(static_cast<u16>(value.Stage) | (static_cast<u16>(value.Type) << 8));
-                }
-            };
-
-            struct Eq
-            {
-                bool operator()(const TableKey& lhs, const TableKey& rhs) const
-                {
-                    return lhs.Stage == rhs.Stage && lhs.Type == rhs.Type;
-                }
-            };
-        };
-
         struct TableMeta
         {
-            std::vector<D3D12_DESCRIPTOR_RANGE1> ranges{};
+            std::vector<D3D12_DESCRIPTOR_RANGE1> Ranges{};
+            u32 Size{};
             u32 Index{};
             u32 RootIndex{};
             FShaderStage Stage{};
-            RangeType Type{};
+            FShaderLayoutGroupView View{};
 
             TableMeta() = default;
 
-            explicit TableMeta(const u32 index, const FShaderStage stage, const RangeType type)
-                : Index(index), Stage(stage), Type(type)
+            explicit TableMeta(const u32 index, const FShaderStage stage, const FShaderLayoutGroupView view)
             {
+                Index = index;
+                Stage = stage;
+                View = view;
             }
         };
 
-        struct ItemMeta
+        struct TableGroup
         {
-            // Const | Direct 时是 Root Index，InTable 时是 Table 内的 Index
-            u32 Index{};
-            // InTable 时表示在哪个 Table
-            TableScope Table{};
-            ItemType Type{};
-            RangeType RangeType{};
+            std::vector<TableMeta> Metas{};
+            std::vector<FShaderLayoutGroupInfo> Infos{};
+            TableScope Scope{};
+            bool Sampler{};
         };
 
-        virtual std::span<ItemMeta> GetItemMetas() noexcept = 0;
-        virtual std::array<std::span<TableMeta>, 2> GetTableMetas() noexcept = 0;
+        virtual std::span<TableGroup> GetTableGroups() noexcept = 0;
     };
 
     struct D3d12ShaderLayout final : Object<D3d12ShaderLayout, ID3d12ShaderLayout>
@@ -101,9 +56,9 @@ namespace Coplt
         ComPtr<ID3D12RootSignature> m_root_signature{};
         std::vector<FShaderLayoutItemDefine> m_layout_item_defines{};
         // 长度和 m_layout_item_defines 相同
-        std::vector<ItemMeta> m_item_metas{};
-        // [Common, Material]
-        std::vector<TableMeta> m_table_metas[2]{};
+        std::vector<FShaderLayoutItemInfo> m_item_infos{};
+        std::vector<FShaderLayoutGroupClass> m_group_classes{};
+        std::vector<TableGroup> m_table_groups{};
 
         explicit D3d12ShaderLayout(Rc<D3d12GpuDevice>&& device, const FShaderLayoutCreateOptions& options);
 
@@ -112,9 +67,10 @@ namespace Coplt
         void* GetRootSignaturePtr() noexcept override;
 
         const FShaderLayoutItemDefine* GetItemDefines(u32* out_count) noexcept override;
+        const FShaderLayoutItemInfo* GetItemInfos(u32* out_count) noexcept override;
+        const FShaderLayoutGroupClass* GetGroupClasses(u32* out_count) noexcept override;
 
-        std::span<ItemMeta> GetItemMetas() noexcept override;
-        std::array<std::span<TableMeta>, 2> GetTableMetas() noexcept override;
+        std::span<TableGroup> GetTableGroups() noexcept override;
     };
 
     struct D3d12ShaderInputLayout final : Object<D3d12ShaderInputLayout, FD3d12ShaderInputLayout>
diff --git a/Coplt.Graphics.Native/D3d12/Src/Library.cc b/Coplt.Graphics.Native/D3d12/Src/Library.cc
index 07948fd..beccedb 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Library.cc
+++ b/Coplt.Graphics.Native/D3d12/Src/Library.cc
@@ -11,6 +11,7 @@ using namespace Coplt;
 
 void Coplt_Graphics_D3d12_Create_Instance(FResult* r, const FInstanceCreateOptions& options, FInstance** out)
 {
+    cpptrace::register_terminate_handler();
     *r = feb([&]
     {
         *out = new D3d12Instance(options);
diff --git a/Coplt.Graphics.Native/D3d12/Src/Queue.h b/Coplt.Graphics.Native/D3d12/Src/Queue.h
index 4208ae3..2a856e2 100644
--- a/Coplt.Graphics.Native/D3d12/Src/Queue.h
+++ b/Coplt.Graphics.Native/D3d12/Src/Queue.h
@@ -9,6 +9,7 @@
 #include "../../Api/Include/Object.h"
 #include "../FFI/Queue.h"
 #include "Command.h"
+#include "DescriptorManager.h"
 #include "Executor.h"
 
 namespace Coplt
diff --git a/Coplt.Graphics.Native/D3d12/Src/View.cc b/Coplt.Graphics.Native/D3d12/Src/View.cc
new file mode 100644
index 0000000..4fc596f
--- /dev/null
+++ b/Coplt.Graphics.Native/D3d12/Src/View.cc
@@ -0,0 +1,359 @@
+#include "../Include/View.h"
+#include "../Include/GraphicsFormat.h"
+
+using namespace Coplt;
+
+enum View::Type View::Type() const
+{
+    return m_type;
+}
+
+Rc<D3d12GpuBuffer>& View::Buffer()
+{
+    if (m_type != Type::Buffer)
+        COPLT_THROW("null");
+    return m_buffer;
+}
+
+const Rc<D3d12GpuBuffer>& View::Buffer() const
+{
+    if (m_type != Type::Buffer)
+        COPLT_THROW("null");
+    return m_buffer;
+}
+
+View::~View()
+{
+    // ReSharper disable once CppDefaultCaseNotHandledInSwitchStatement
+    switch (m_type)
+    {
+    case Type::None:
+        return;
+    case Type::Buffer:
+        m_buffer.~Rc();
+        return;
+    }
+    std::unreachable();
+}
+
+// ReSharper disable once CppPossiblyUninitializedMember
+View::View() : m_type(Type::None)
+{
+}
+
+View::View(const View& other) : m_type(other.m_type)
+{
+    switch (m_type)
+    {
+    case Type::None:
+        break;
+    case Type::Buffer:
+        new(std::addressof(m_buffer)) Rc(other.m_buffer);
+        break;
+    }
+}
+
+View::View(View&& other) noexcept : m_type(std::exchange(other.m_type, Type::None))
+{
+    switch (m_type)
+    {
+    case Type::None:
+        break;
+    case Type::Buffer:
+        new(std::addressof(m_buffer)) Rc(std::move(other.m_buffer));
+        break;
+    }
+}
+
+View& View::operator=(const View& view) noexcept
+{
+    this->~View();
+    new(this) View(view);
+    return *this;
+}
+
+View& View::operator=(View&& view) noexcept
+{
+    this->~View();
+    new(this) View(std::forward<View>(view));
+    return *this;
+}
+
+View::View(const FView& view)
+{
+    switch (view.Type)
+    {
+    case FViewType::None:
+        m_type = Type::None;
+        break;
+    case FViewType::Buffer:
+        m_type = Type::Buffer;
+        if (view.Buffer == nullptr) new(std::addressof(m_buffer)) Rc<D3d12GpuBuffer>();
+        const auto db = view.Buffer->QueryInterface<D3d12GpuBuffer>();
+        if (db == nullptr)
+            COPLT_THROW("GpuBuffer from different backends.");
+        new(std::addressof(m_buffer)) Rc(Rc<D3d12GpuBuffer>::UnsafeClone(db));
+        break;
+    }
+}
+
+View& View::operator=(const FView& view)
+{
+    this->~View();
+    new(this) View(view);
+    return *this;
+}
+
+View::View(const Rc<D3d12GpuBuffer>& buffer) : m_type(Type::Buffer)
+{
+    new(std::addressof(m_buffer)) Rc(buffer);
+}
+
+View::View(Rc<D3d12GpuBuffer>&& buffer) : m_type(Type::Buffer)
+{
+    new(std::addressof(m_buffer)) Rc(std::move(buffer));
+}
+
+View& View::operator=(const Rc<D3d12GpuBuffer>& buffer)
+{
+    this->~View();
+    new(this) View(buffer);
+    return *this;
+}
+
+View& View::operator=(Rc<D3d12GpuBuffer>&& buffer)
+{
+    this->~View();
+    new(this) View(std::forward<Rc<D3d12GpuBuffer>>(buffer));
+    return *this;
+}
+
+void View::CreateDescriptor(
+    NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, const CD3DX12_CPU_DESCRIPTOR_HANDLE handle, const FShaderLayoutGroupView type
+) const
+{
+    switch (Type())
+    {
+    case Type::None:
+        CreateNullDescriptor(device, def, handle, type);
+        break;
+    case Type::Buffer:
+        CreateBufferDescriptor(device, def, handle, type);
+        break;
+    }
+}
+
+void View::CreateNullDescriptor(
+    NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, CD3DX12_CPU_DESCRIPTOR_HANDLE handle, const FShaderLayoutGroupView view
+)
+{
+    switch (view)
+    {
+    case FShaderLayoutGroupView::Cbv:
+        {
+            device->CreateConstantBufferView(nullptr, handle);
+            break;
+        }
+    case FShaderLayoutGroupView::Srv:
+        {
+            D3D12_SHADER_RESOURCE_VIEW_DESC desc{};
+            desc.Format = ToDx(def.Format);
+            desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+            switch (def.Type)
+            {
+            case FShaderLayoutItemType::ConstantBuffer:
+                COPLT_THROW("Srv not support ConstantBuffer");
+            case FShaderLayoutItemType::Buffer:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+                break;
+            case FShaderLayoutItemType::RawBuffer:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+                desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
+                break;
+            case FShaderLayoutItemType::StructureBuffer:
+            case FShaderLayoutItemType::StructureBufferWithCounter:
+                desc.Format = DXGI_FORMAT_UNKNOWN;
+                desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+                desc.Buffer.FirstElement = 0;
+                desc.Buffer.NumElements = 1;
+                desc.Buffer.StructureByteStride = 1;
+                break;
+            case FShaderLayoutItemType::Texture1D:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
+                desc.Texture1D.MostDetailedMip = 0;
+                desc.Texture1D.MipLevels = 1;
+                desc.Texture1D.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::Texture1DArray:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
+                desc.Texture1DArray.MostDetailedMip = 0;
+                desc.Texture1DArray.MipLevels = 1;
+                desc.Texture1DArray.FirstArraySlice = 0;
+                desc.Texture1DArray.ArraySize = 1;
+                desc.Texture1DArray.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::Texture2D:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
+                desc.Texture2D.MostDetailedMip = 0;
+                desc.Texture2D.MipLevels = 1;
+                desc.Texture2D.PlaneSlice = 0;
+                desc.Texture2D.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::Texture2DArray:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+                desc.Texture2DArray.MostDetailedMip = 0;
+                desc.Texture2DArray.MipLevels = 1;
+                desc.Texture2DArray.FirstArraySlice = 0;
+                desc.Texture2DArray.ArraySize = 1;
+                desc.Texture2DArray.PlaneSlice = 0;
+                desc.Texture2DArray.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::Texture2DMultisample:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMS;
+                break;
+            case FShaderLayoutItemType::Texture2DArrayMultisample:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
+                desc.Texture2DMSArray.FirstArraySlice = 0;
+                desc.Texture2DMSArray.ArraySize = 1;
+                break;
+            case FShaderLayoutItemType::Texture3D:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+                desc.Texture3D.MostDetailedMip = 0;
+                desc.Texture3D.MipLevels = 1;
+                desc.Texture3D.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::TextureCube:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+                desc.TextureCube.MostDetailedMip = 0;
+                desc.TextureCube.MipLevels = 1;
+                desc.TextureCube.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::TextureCubeArray:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
+                desc.TextureCubeArray.MostDetailedMip = 0;
+                desc.TextureCubeArray.MipLevels = 1;
+                desc.TextureCubeArray.First2DArrayFace = 0;
+                desc.TextureCubeArray.NumCubes = 1;
+                desc.TextureCubeArray.ResourceMinLODClamp = 0;
+                break;
+            case FShaderLayoutItemType::Sampler:
+                COPLT_THROW("Srv not support sampler");
+            case FShaderLayoutItemType::RayTracingAccelerationStructure:
+                desc.ViewDimension = D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE;
+                break;
+            }
+            device->CreateShaderResourceView(nullptr, &desc, handle);
+            break;
+        }
+    case FShaderLayoutGroupView::Uav:
+        {
+            D3D12_UNORDERED_ACCESS_VIEW_DESC desc{};
+            desc.Format = ToDx(def.Format);
+            switch (def.Type)
+            {
+            case FShaderLayoutItemType::ConstantBuffer:
+                COPLT_THROW("Uav not support ConstantBuffer");
+            case FShaderLayoutItemType::Buffer:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+                break;
+            case FShaderLayoutItemType::RawBuffer:
+                desc.Format = DXGI_FORMAT_R32_TYPELESS;
+                desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+                desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
+                break;
+            case FShaderLayoutItemType::StructureBuffer:
+            case FShaderLayoutItemType::StructureBufferWithCounter:
+                desc.Format = DXGI_FORMAT_UNKNOWN;
+                desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+                desc.Buffer.FirstElement = 0;
+                desc.Buffer.NumElements = 1;
+                desc.Buffer.StructureByteStride = 1;
+                desc.Buffer.CounterOffsetInBytes = 0;
+                break;
+            case FShaderLayoutItemType::Texture1D:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1D;
+                desc.Texture1D.MipSlice = 0;
+                break;
+            case FShaderLayoutItemType::Texture1DArray:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
+                desc.Texture1DArray.MipSlice = 0;
+                desc.Texture1DArray.FirstArraySlice = 0;
+                desc.Texture1DArray.ArraySize = 1;
+                break;
+            case FShaderLayoutItemType::Texture2D:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
+                desc.Texture2D.MipSlice = 0;
+                desc.Texture2D.PlaneSlice = 0;
+                break;
+            case FShaderLayoutItemType::Texture2DArray:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
+                desc.Texture2DArray.MipSlice = 0;
+                desc.Texture2DArray.FirstArraySlice = 0;
+                desc.Texture2DArray.ArraySize = 1;
+                desc.Texture2DArray.PlaneSlice = 0;
+                break;
+            case FShaderLayoutItemType::Texture2DMultisample:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DMS;
+                break;
+            case FShaderLayoutItemType::Texture2DArrayMultisample:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DMSARRAY;
+                break;
+            case FShaderLayoutItemType::Texture3D:
+                desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
+                desc.Texture3D.MipSlice = 0;
+                desc.Texture3D.FirstWSlice = 0;
+                desc.Texture3D.WSize = 1;
+                break;
+            case FShaderLayoutItemType::TextureCube:
+                COPLT_THROW("Uav not support TextureCube");
+            case FShaderLayoutItemType::TextureCubeArray:
+                COPLT_THROW("Uav not support TextureCubeArray");
+            case FShaderLayoutItemType::Sampler:
+                COPLT_THROW("Uav not support Sampler");
+            case FShaderLayoutItemType::RayTracingAccelerationStructure:
+                COPLT_THROW("Uav not support RayTracingAccelerationStructure");
+            }
+            device->CreateUnorderedAccessView(nullptr, nullptr, &desc, handle);
+            break;
+        }
+    case FShaderLayoutGroupView::Sampler:
+        {
+            D3D12_SAMPLER_DESC desc{};
+            desc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR;
+            desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
+            desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
+            desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
+            desc.MaxLOD = FLT_MAX;
+            device->CreateSampler(&desc, handle);
+            break;
+        }
+    default:
+        std::unreachable();
+    }
+}
+
+void View::CreateBufferDescriptor(
+    NonNull<ID3D12Device2> device, const FShaderLayoutItemDefine& def, CD3DX12_CPU_DESCRIPTOR_HANDLE handle, FShaderLayoutGroupView type
+) const
+{
+    auto buffer = Buffer().get();
+    switch (type)
+    {
+    case FShaderLayoutGroupView::Cbv:
+        {
+            D3D12_CONSTANT_BUFFER_VIEW_DESC desc{};
+            desc.BufferLocation = buffer->m_resource->m_resource->GetGPUVirtualAddress();
+            desc.SizeInBytes = buffer->m_size;
+            device->CreateConstantBufferView(&desc, handle);
+            break;
+        }
+    case FShaderLayoutGroupView::Srv:
+        // todo
+        break;
+    case FShaderLayoutGroupView::Uav:
+        // todo
+        break;
+    case FShaderLayoutGroupView::Sampler:
+        COPLT_THROW("Buffer cannot be used as a sampler");
+    }
+}
diff --git a/Examples/Colorful/Colorful.csproj b/Examples/Colorful/Colorful.csproj
index a61559b..22e9c0f 100644
--- a/Examples/Colorful/Colorful.csproj
+++ b/Examples/Colorful/Colorful.csproj
@@ -26,7 +26,7 @@
         <PackageReference Include="Serilog.Sinks.Debug" Version="3.0.0"/>
         <PackageReference Include="Serilog.Sinks.File" Version="6.0.0"/>
         <PackageReference Include="Microsoft.Direct3D.D3D12" Version="1.715.1-preview" GeneratePathProperty="true"/>
-        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2407.12" GeneratePathProperty="true" ExcludeAssets="all"/>
+        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2502.8" GeneratePathProperty="true" ExcludeAssets="all" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/Examples/Colorful/Example.cs b/Examples/Colorful/Example.cs
index eed5976..fce2a29 100644
--- a/Examples/Colorful/Example.cs
+++ b/Examples/Colorful/Example.cs
@@ -56,12 +56,12 @@ protected override async Task LoadResources(CommandList cmd)
             },
             Name: "Args"
         );
-        // cmd.Bind(ShaderBinding, [new(0, ArgBuffer)]);
+        cmd.Bind(ShaderBinding, [new(0, ArgBuffer)]);
     }
     protected override void Render(CommandList cmd, Time time)
     {
         cmd.Upload(ArgBuffer, [(float)time.Total.TotalSeconds]);
         using var render = cmd.Render([new(Output, new float4(0.83f, 0.8f, 0.97f, 1f))]);
-        render.Draw(Pipeline, 4);
+        render.Draw(Pipeline, 4, Binding: ShaderBinding);
     }
 }
diff --git a/Examples/Colorful/Shaders/Shader.hlsl b/Examples/Colorful/Shaders/Shader.hlsl
index be05d9c..1ac8239 100644
--- a/Examples/Colorful/Shaders/Shader.hlsl
+++ b/Examples/Colorful/Shaders/Shader.hlsl
@@ -32,5 +32,5 @@ cbuffer Args : register(b0)
 [shader("pixel")]
 float4 Pixel(Varying input) : SV_Target
 {
-    return float4(input.Uv, time, 1);
+    return float4(input.Uv, (cos(time) + 1) * 0.5, 1);
 }
diff --git a/Examples/HelloTriangle/HelloTriangle.csproj b/Examples/HelloTriangle/HelloTriangle.csproj
index a61559b..22e9c0f 100644
--- a/Examples/HelloTriangle/HelloTriangle.csproj
+++ b/Examples/HelloTriangle/HelloTriangle.csproj
@@ -26,7 +26,7 @@
         <PackageReference Include="Serilog.Sinks.Debug" Version="3.0.0"/>
         <PackageReference Include="Serilog.Sinks.File" Version="6.0.0"/>
         <PackageReference Include="Microsoft.Direct3D.D3D12" Version="1.715.1-preview" GeneratePathProperty="true"/>
-        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2407.12" GeneratePathProperty="true" ExcludeAssets="all"/>
+        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2502.8" GeneratePathProperty="true" ExcludeAssets="all" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/Examples/HelloTriangle/Shaders/Shader.hlsl b/Examples/HelloTriangle/Shaders/Shader.hlsl
index 63b5d43..e3cf836 100644
--- a/Examples/HelloTriangle/Shaders/Shader.hlsl
+++ b/Examples/HelloTriangle/Shaders/Shader.hlsl
@@ -48,9 +48,13 @@ float SdTriangle(float2 p, float2 p0, float2 p1, float2 p2)
     float d2 = dot2(v2 - e2 * clamp(dot(v2, e2) / dot(e2, e2), 0.0, 1.0));
 
     float o = e0.x * e2.y - e0.y * e2.x;
-    float2 d = min(min(float2(d0, o * (v0.x * e0.y - v0.y * e0.x)),
-                       float2(d1, o * (v1.x * e1.y - v1.y * e1.x))),
-                   float2(d2, o * (v2.x * e2.y - v2.y * e2.x)));
+    float2 d = min(
+        min(
+            float2(d0, o * (v0.x * e0.y - v0.y * e0.x)),
+            float2(d1, o * (v1.x * e1.y - v1.y * e1.x))
+        ),
+        float2(d2, o * (v2.x * e2.y - v2.y * e2.x))
+    );
     return -sqrt(d.x) * sign(d.y);
 }
 
diff --git a/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj b/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
index a61559b..22e9c0f 100644
--- a/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
+++ b/Examples/HelloTriangleVertex/HelloTriangleVertex.csproj
@@ -26,7 +26,7 @@
         <PackageReference Include="Serilog.Sinks.Debug" Version="3.0.0"/>
         <PackageReference Include="Serilog.Sinks.File" Version="6.0.0"/>
         <PackageReference Include="Microsoft.Direct3D.D3D12" Version="1.715.1-preview" GeneratePathProperty="true"/>
-        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2407.12" GeneratePathProperty="true" ExcludeAssets="all"/>
+        <PackageReference Include="Microsoft.Direct3D.DXC" Version="1.8.2502.8" GeneratePathProperty="true" ExcludeAssets="all" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/Examples/HelloTriangleVertex/Shaders/Shader.hlsl b/Examples/HelloTriangleVertex/Shaders/Shader.hlsl
index 6dfa510..455a5bf 100644
--- a/Examples/HelloTriangleVertex/Shaders/Shader.hlsl
+++ b/Examples/HelloTriangleVertex/Shaders/Shader.hlsl
@@ -34,9 +34,13 @@ float SdTriangle(float2 p, float2 p0, float2 p1, float2 p2)
     float d2 = dot2(v2 - e2 * clamp(dot(v2, e2) / dot(e2, e2), 0.0, 1.0));
 
     float o = e0.x * e2.y - e0.y * e2.x;
-    float2 d = min(min(float2(d0, o * (v0.x * e0.y - v0.y * e0.x)),
-                       float2(d1, o * (v1.x * e1.y - v1.y * e1.x))),
-                   float2(d2, o * (v2.x * e2.y - v2.y * e2.x)));
+    float2 d = min(
+        min(
+            float2(d0, o * (v0.x * e0.y - v0.y * e0.x)),
+            float2(d1, o * (v1.x * e1.y - v1.y * e1.x))
+        ),
+        float2(d2, o * (v2.x * e2.y - v2.y * e2.x))
+    );
     return -sqrt(d.x) * sign(d.y);
 }