diff --git a/src/base/base_log.h b/src/base/base_log.h
index fc7b5229..01ba7ce8 100644
--- a/src/base/base_log.h
+++ b/src/base/base_log.h
@@ -50,7 +50,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Critical)
   #define LogCritical(msg) Log_(LogLevel_Critical, msg)
-  #define LogCriticalF(fmt_lit, ...) LogF_(LogLevel_Critical, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogCriticalF(fmt_lit, ...) LogF_(LogLevel_Critical, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogCritical(msg)
   #define LogCriticalF(...)
@@ -58,7 +58,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Error)
   #define LogError(msg) Log_(LogLevel_Error, msg)
-  #define LogErrorF(fmt_lit, ...) LogF_(LogLevel_Error, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogErrorF(fmt_lit, ...) LogF_(LogLevel_Error, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogError(msg)
   #define LogErrorF(...)
@@ -66,7 +66,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Warning)
   #define LogWarning(msg) Log_(LogLevel_Warning, msg)
-  #define LogWarningF(fmt_lit, ...) LogF_(LogLevel_Warning, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogWarningF(fmt_lit, ...) LogF_(LogLevel_Warning, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogWarning(msg)
   #define LogWarningF(...)
@@ -74,7 +74,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Success)
   #define LogSuccess(msg) Log_(LogLevel_Success, msg)
-  #define LogSuccessF(fmt_lit, ...) LogF_(LogLevel_Success, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogSuccessF(fmt_lit, ...) LogF_(LogLevel_Success, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogSuccess(msg)
   #define LogSuccessF(...)
@@ -82,7 +82,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Info)
   #define LogInfo(msg) Log_(LogLevel_Info, msg)
-  #define LogInfoF(fmt_lit, ...) LogF_(LogLevel_Info, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogInfoF(fmt_lit, ...) LogF_(LogLevel_Info, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogInfo(msg)
   #define LogInfoF(...)
@@ -90,7 +90,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Debug)
   #define LogDebug(msg) Log_(LogLevel_Debug, msg)
-  #define LogDebugF(fmt_lit, ...) LogF_(LogLevel_Debug, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogDebugF(fmt_lit, ...) LogF_(LogLevel_Debug, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogDebug(msg)
   #define LogDebugF(...)
@@ -98,7 +98,7 @@ Struct(LogEventsArray)
 
 #if LogLevel(LogLevel_Trace)
   #define LogTrace(msg) Log_(LogLevel_Trace, msg)
-  #define LogTraceF(fmt_lit, ...) LogF_(LogLevel_Trace, Lit(fmt_lit) , ## __VA_ARGS__, FmtEnd)
+  #define LogTraceF(fmt_lit, ...) LogF_(LogLevel_Trace, Lit(fmt_lit) , ##__VA_ARGS__, FmtEnd)
 #else
   #define LogTrace(msg)
   #define LogTraceF(...)
diff --git a/src/gpu/gpu_core.h b/src/gpu/gpu_core.h
index 43f954ad..822e93c6 100644
--- a/src/gpu/gpu_core.h
+++ b/src/gpu/gpu_core.h
@@ -3,7 +3,6 @@
 
 Struct(G_ArenaHandle)       { u64 v; };
 Struct(G_CommandListHandle) { u64 v; };
-Struct(G_ResourceHandle)    { u64 v; };
 Struct(G_SwapchainHandle)   { u64 v; };
 
 #define G_IsArenaNil(h)       ((h).v == 0)
@@ -16,11 +15,11 @@ Struct(G_SwapchainHandle)   { u64 v; };
 
 #define G_IsMultiQueueEnabled 1
 
-Enum(G_QueueFamily)
+Enum(G_Family)
 {
-  G_QueueFamily_Graphics,
-  G_QueueFamily_Compute,
-  G_QueueFamily_Copy
+  G_Family_Graphics,
+  G_Family_Compute,
+  G_Family_Copy
 };
 
 Enum(G_QueueKind)
@@ -382,16 +381,9 @@ Enum(G_BlendMode)
   G_BlendMode_CompositePremultipliedAlpha,
 };
 
-Struct(G_IndexBufferDesc)
-{
-  u32 count;
-  u32 stride;  // Either 2 for u16 indices, or 4 for u32 indices
-  G_ResourceHandle resource;
-};
-
 Struct(G_RenderTargetDesc)
 {
-  G_ResourceHandle resource;
+  G_TextureRef texture;
   G_BlendMode blend;
   i32 mip;
 };
@@ -427,7 +419,7 @@ void G_ResetArena(G_CommandListHandle cl_handle, G_ArenaHandle arena_handle);
 ////////////////////////////////////////////////////////////
 //~ @hookdecl Memory
 
-G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_arena, G_MemoryDesc desc);
+G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_arena, G_MemoryDesc memory_desc);
 
 #define G_PushBuffer(_cl, _arena, _type, _count, ...) ((G_BufferRef) { .v = G_PushMemory((_cl), (_arena), \
   (G_MemoryDesc) {                                                                                       \
@@ -575,6 +567,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl, G_ArenaHandle gpu_are
 
 //- Count
 
+u64     G_GetStride(G_BufferRef buffer);
 u64     G_CountBuffer(G_BufferRef buffer);
 u64     G_CountBufferBytes(G_BufferRef buffer);
 i32     G_Count1D(G_TextureRef texture);
@@ -587,8 +580,8 @@ i32     G_CountMips(G_TextureRef texture);
 
 //- Map
 
-void *G_CpuAddressFromBuffer(G_BufferRef buffer);
-#define G_StructFromBuffer(buffer, type) (type *)G_CpuAddressFromBuffer(buffer)
+void *G_CpuPointerFromBuffer(G_BufferRef buffer);
+#define G_Deref(buffer, type) ((type *)G_CpuPointerFromBuffer(buffer))
 
 ////////////////////////////////////////////////////////////
 //~ @hookdecl Shader resource reference
@@ -650,7 +643,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl);
 void G_SetConstantEx(G_CommandListHandle cl, i32 slot, void *src_32bit, u32 size);
 
 #define G_SetConstant(cl, name, value) do {                    \
-    CAT(name, __shaderconstanttype) __src;                     \
+    CAT(__ShaderConstantType_,name) __src;                     \
     __src.v = value;                                           \
     G_SetConstantEx((cl), (name), &__src, sizeof(__src));      \
   } while (0)
@@ -694,7 +687,7 @@ void G_ComputeEx(G_CommandListHandle cl, ComputeShaderDesc cs, Vec3I32 threads);
 void G_Draw(
   G_CommandListHandle cl,
   VertexShaderDesc vs, PixelShaderDesc ps,
-  u32 instances_count, G_IndexBufferDesc index_buffer,
+  u32 instances_count, G_BufferRef indices,
   u32 render_targets_count, G_RenderTargetDesc *render_targets,
   Rng3 viewport, Rng2 scissor,
   G_DrawMode draw_mode
@@ -702,7 +695,7 @@ void G_Draw(
 
 //- Clear
 
-void G_ClearRenderTarget(G_CommandListHandle cl, G_TextureRef render_target, Vec4 color, i32 mip);
+void G_ClearRenderTarget(G_CommandListHandle cl, G_TextureRef texture, Vec4 color, i32 mip);
 
 ////////////////////////////////////////////////////////////
 //~ @hookdecl Queue synchronization
diff --git a/src/gpu/gpu_dx12/gpu_dx12_core.c b/src/gpu/gpu_dx12/gpu_dx12_core.c
index a70b2873..0eb8acc4 100644
--- a/src/gpu/gpu_dx12/gpu_dx12_core.c
+++ b/src/gpu/gpu_dx12/gpu_dx12_core.c
@@ -484,18 +484,14 @@ void G_Bootstrap(void)
         ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(heap->d3d_heap, &heap->start_handle);
       }
 
-      // Push nil descriptor at index 0
       if (SUCCEEDED(hr))
       {
-        G_D12_DescriptorDesc descriptor_desc = Zi;
-        descriptor_desc.resource = 0;
-        descriptor_desc.bundle_count = G_D12_MaxDescriptorBundleCount;
-
-        // Push an empty descriptor at index 0, so that a handle with a value of 0 always represents nil
-        G_D12_Arena *gpu_perm = G_D12_ArenaFromHandle(G_PermArena());
-        G_D12_Descriptor *nil_descriptor = G_D12_PushDescriptor(gpu_perm, descriptor_desc, heap_kind);
-        Assert(nil_descriptor->base_index == 0);
-
+        // Push nil descriptor at index 0
+        {
+          G_D12_Arena *gpu_perm = G_D12_ArenaFromHandle(G_PermArena());
+          G_D12_Descriptor *nil_descriptor = G_D12_PushDescriptor(gpu_perm, 1, heap_kind);
+          Assert(nil_descriptor->base_index == 0);
+        }
         G_D12_SetObjectName((ID3D12Object *)heap->d3d_heap, desc.name);
       }
 
@@ -628,11 +624,6 @@ G_D12_CmdList *G_D12_CmdListFromHandle(G_CommandListHandle handle)
   return (G_D12_CmdList *)handle.v;
 }
 
-G_D12_Resource *G_D12_ResourceFromHandle(G_ResourceHandle handle)
-{
-  return (G_D12_Resource *)handle.v;
-}
-
 G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle)
 {
   return (G_D12_Swapchain *)handle.v;
@@ -657,35 +648,6 @@ D3D12_BARRIER_LAYOUT G_D12_CommonLayoutFromQueueKind(G_QueueKind queue_kind)
   return result;
 }
 
-void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip)
-{
-  DXGI_FORMAT format = G_D12_DxgiFormatFromGpuFormat(resource->texture_format);
-  D3D12_RESOURCE_DESC res_d3d_desc = Zi;
-  {
-    ID3D12Resource_GetDesc(resource->d3d_resource, &res_d3d_desc);
-  }
-  D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = Zi;
-  {
-    rtv_desc.Format = res_d3d_desc.Format;
-    if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE1D)
-    {
-      rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1D;
-      rtv_desc.Texture1D.MipSlice = mip;
-    }
-    else if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D)
-    {
-      rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
-      rtv_desc.Texture2D.MipSlice = mip;
-    }
-    else if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
-    {
-      rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
-      rtv_desc.Texture3D.MipSlice = mip;
-    }
-  }
-  ID3D12Device_CreateRenderTargetView(G_D12.device, resource->d3d_resource, &rtv_desc, rtv_handle);
-}
-
 void G_D12_SetObjectName(ID3D12Object *object, String name)
 {
   TempArena scratch = BeginScratchNoConflict();
@@ -1051,9 +1013,9 @@ G_D12_RawCommandList *G_D12_PrepareRawCommandList(G_QueueKind queue_kind)
         G_D12_Arena *gpu_perm = G_D12_ArenaFromHandle(G_PermArena());
         for (u32 rtv_idx = 0; rtv_idx < countof(cl->rtv_descriptors); ++rtv_idx)
         {
-          cl->rtv_descriptors[rtv_idx] = G_D12_PushDescriptor(gpu_perm, G_D12_DescriptorHeapKind_Rtv);
+          cl->rtv_descriptors[rtv_idx] = G_D12_PushDescriptor(gpu_perm, 1, G_D12_DescriptorHeapKind_Rtv);
         }
-        cl->rtv_clear_descriptor = G_D12_PushDescriptor(gpu_perm, G_D12_DescriptorHeapKind_Rtv);
+        cl->rtv_clear_descriptor = G_D12_PushDescriptor(gpu_perm, 1, G_D12_DescriptorHeapKind_Rtv);
       }
     }
 
@@ -1289,13 +1251,104 @@ void G_D12_ResetArena(G_D12_CmdList *cl, G_D12_Arena *gpu_arena)
 
 
 
-G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, G_D12_DescriptorDesc desc, G_D12_DescriptorHeapKind heap_kind)
+
+
+
+
+
+
+
+// void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip)
+// {
+//   DXGI_FORMAT format = G_D12_DxgiFormatFromGpuFormat(resource->texture_format);
+//   D3D12_RESOURCE_DESC res_d3d_desc = Zi;
+//   {
+//     ID3D12Resource_GetDesc(resource->d3d_resource, &res_d3d_desc);
+//   }
+//   D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = Zi;
+//   {
+//     rtv_desc.Format = res_d3d_desc.Format;
+//     if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE1D)
+//     {
+//       rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1D;
+//       rtv_desc.Texture1D.MipSlice = mip;
+//     }
+//     else if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D)
+//     {
+//       rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
+//       rtv_desc.Texture2D.MipSlice = mip;
+//     }
+//     else if (res_d3d_desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
+//     {
+//       rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
+//       rtv_desc.Texture3D.MipSlice = mip;
+//     }
+//   }
+//   ID3D12Device_CreateRenderTargetView(G_D12.device, resource->d3d_resource, &rtv_desc, rtv_handle);
+// }
+
+
+
+
+
+
+
+
+// FIXME: Header
+
+
+
+
+
+
+
+G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, u64 bundle_count, G_D12_DescriptorHeapKind heap_kind)
 {
   // FIXME: Impl
-  G_D12_Descriptor result = 0;
+  G_D12_Descriptor *result = 0;
   return result;
 }
 
+void G_D12_InitRtvDescriptorFromResource(G_D12_Descriptor *descriptor, G_D12_Resource *resource, i32 mip)
+{
+  // FIXME: Impl
+}
+
+
+
+G_D12_Descriptor *G_D12_DescriptorFromBufferRef(G_BufferRef ref)
+{
+  // FIXME: Impl
+  G_D12_Descriptor *result = 0;
+  return result;
+}
+
+G_D12_Descriptor *G_D12_DescriptorFromTextureRef(G_TextureRef ref)
+{
+  G_D12_Descriptor *result = 0;
+  return result;
+}
+
+G_D12_Descriptor *G_D12_DescriptorFromSamplerRef(G_SamplerRef ref)
+{
+  G_D12_Descriptor *result = 0;
+  return result;
+}
+
+G_D12_Resource *G_D12_ResourceFromBufferRef(G_BufferRef ref)
+{
+  return G_D12_DescriptorFromBufferRef(ref)->resource;
+}
+
+G_D12_Resource *G_D12_ResourceFromTextureRef(G_TextureRef ref)
+{
+  return G_D12_DescriptorFromTextureRef(ref)->resource;
+}
+
+G_D12_Resource *G_D12_ResourceFromSamplerRef(G_SamplerRef ref)
+{
+  return G_D12_DescriptorFromSamplerRef(ref)->resource;
+}
 
 
 
@@ -1321,7 +1374,7 @@ G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, G_D12_DescriptorD
 
 
 
-G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle gpu_arena_handle, G_MemoryDesc memory_dsec)
+G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle gpu_arena_handle, G_MemoryDesc memory_desc)
 {
   Arena *perm = PermArena();
   G_D12_Arena *gpu_arena = G_D12_ArenaFromHandle(gpu_arena_handle);
@@ -1329,22 +1382,22 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
   G_QueueKind queue_kind = cl->queue_kind;
   G_D12_Resource *resource = 0;
 
-  b32 is_buffer = desc.kind == G_MemoryKind_Buffer;
+  b32 is_buffer = memory_desc.kind == G_MemoryKind_Buffer;
   b32 is_texture = (
-    desc.kind == G_MemoryKind_Texture1D ||
-    desc.kind == G_MemoryKind_Texture2D ||
-    desc.kind == G_MemoryKind_Texture3D
+    memory_desc.kind == G_MemoryKind_Texture1D ||
+    memory_desc.kind == G_MemoryKind_Texture2D ||
+    memory_desc.kind == G_MemoryKind_Texture3D
   );
-  b32 is_sampler = desc.kind == G_MemoryKind_Sampler;
+  b32 is_sampler = memory_desc.kind == G_MemoryKind_Sampler;
   G_MemoryFlag flags = (
-    is_buffer ? desc.buffer.flags :
-    is_texture ? desc.texture.flags :
-    desc.sampler.flags
+    is_buffer ? memory_desc.buffer.flags :
+    is_texture ? memory_desc.texture.flags :
+    memory_desc.sampler.flags
   );
   String new_name = (
-    is_buffer ? desc.buffer.name :
-    is_texture ? desc.texture.name :
-    desc.sampler.name
+    is_buffer ? memory_desc.buffer.name :
+    is_texture ? memory_desc.texture.name :
+    memory_desc.sampler.name
   );
   new_name.len = MinU64(new_name.len, G_D12_MaxNameLen);
 
@@ -1360,15 +1413,15 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
   {
     G_D12_ResourceHeapKind heap_kind = G_D12_ResourceHeapKind_Gpu;
     // Heap flags
-    if (flags & G_MemoryFlag_HostMemory)
+    if (flags & G_MemoryFlag_HostCached)
     {
-      heap_kind = G_D12_ResourceHeapKind_Cpu;
-      if (flags & G_MemoryFlag_Uncached)
-      {
-        heap_kind = G_D12_ResourceHeapKind_CpuWriteCombined;
-      }
+      heap_kind = G_D12_ResourceHeapKind_CpuWriteBack;
     }
-    if (flags & G_MemoryFlag_ZeroMemory)
+    else if (flags & G_MemoryFlag_HostUncached)
+    {
+      heap_kind = G_D12_ResourceHeapKind_CpuWriteCombined;
+    }
+    if (flags & G_MemoryFlag_Zero)
     {
       can_reuse = 0;
     }
@@ -1377,7 +1430,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
       heap_flags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
     }
     // Heap props
-    if (heap_kind == G_D12_ResourceHeapKind_Cpu)
+    if (heap_kind == G_D12_ResourceHeapKind_CpuWriteBack)
     {
       heap_props.Type = D3D12_HEAP_TYPE_CUSTOM;
       heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_WRITE_BACK;
@@ -1402,45 +1455,47 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 
   D3D12_CLEAR_VALUE clear_value = Zi;
   D3D12_RESOURCE_DESC1 d3d_desc  = Zi;
+  u64 buffer_size = 0;
   if (is_buffer)
   {
     u64 min_buffer_size = 1024;
+    buffer_size = NextPow2U64(MaxU64(memory_desc.buffer.count * memory_desc.buffer.stride, min_buffer_size));
     d3d_desc.Dimension             = D3D12_RESOURCE_DIMENSION_BUFFER;
     d3d_desc.Layout                = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
     d3d_desc.Format                = DXGI_FORMAT_UNKNOWN;
-    d3d_desc.Width                 = NextPow2U64(MaxU64(desc.buffer.size, min_buffer_size));
+    d3d_desc.Width                 = buffer_size;
     d3d_desc.Height                = 1;
     d3d_desc.DepthOrArraySize      = 1;
     d3d_desc.MipLevels             = 1;
     d3d_desc.SampleDesc.Count      = 1;
     d3d_desc.SampleDesc.Quality    = 0;
-    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS * AnyBit(flags, G_MemoryFlag_AllowShaderReadWrite);
+    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
   }
   else if (is_texture)
   {
-    i32 largest_dim = MaxI32(MaxI32(desc.texture.dims.x, desc.texture.dims.y), desc.texture.dims.z);
+    i32 largest_dim = MaxI32(MaxI32(memory_desc.texture.dims.x, memory_desc.texture.dims.y), memory_desc.texture.dims.z);
     i32 max_mips = MinI32(FloorF32(Log2F32(largest_dim)) + 1, G_MaxMips);
     d3d_desc.Dimension = (
-      desc.kind == G_MemoryKind_Texture1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D :
-      desc.kind == G_MemoryKind_Texture2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D :
+      memory_desc.kind == G_MemoryKind_Texture1D ? D3D12_RESOURCE_DIMENSION_TEXTURE1D :
+      memory_desc.kind == G_MemoryKind_Texture2D ? D3D12_RESOURCE_DIMENSION_TEXTURE2D :
       D3D12_RESOURCE_DIMENSION_TEXTURE3D
     );
     d3d_desc.Layout                = D3D12_TEXTURE_LAYOUT_UNKNOWN;
-    d3d_desc.Format                = G_D12_DxgiFormatFromGpuFormat(desc.texture.format);
-    d3d_desc.Width                 = MaxI32(desc.texture.dims.x, 1);
-    d3d_desc.Height                = MaxI32(desc.texture.dims.y, 1);
-    d3d_desc.DepthOrArraySize      = MaxI32(desc.texture.dims.z, 1);
-    d3d_desc.MipLevels             = ClampF32(desc.texture.max_mips, 1, max_mips);
+    d3d_desc.Format                = G_D12_DxgiFormatFromGpuFormat(memory_desc.texture.format);
+    d3d_desc.Width                 = MaxI32(memory_desc.texture.dims.x, 1);
+    d3d_desc.Height                = MaxI32(memory_desc.texture.dims.y, 1);
+    d3d_desc.DepthOrArraySize      = MaxI32(memory_desc.texture.dims.z, 1);
+    d3d_desc.MipLevels             = ClampF32(memory_desc.texture.max_mips, 1, max_mips);
     d3d_desc.SampleDesc.Count      = 1;
     d3d_desc.SampleDesc.Quality    = 0;
-    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS     * AnyBit(flags, G_MemoryFlag_AllowShaderReadWrite);
-    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET        * AnyBit(flags, G_MemoryFlag_AllowRenderTarget);
+    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS     * AnyBit(flags, G_MemoryFlag_AllowTextureRW);
+    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET        * AnyBit(flags, G_MemoryFlag_AllowTextureDraw);
     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL        * AnyBit(flags, G_MemoryFlag_AllowTextureDepthStencil);
-    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS  * (desc.texture.initial_layout == G_Layout_Simultaneous);
-    clear_value.Color[0] = desc.texture.clear_color.x,
-    clear_value.Color[1] = desc.texture.clear_color.y,
-    clear_value.Color[2] = desc.texture.clear_color.z,
-    clear_value.Color[3] = desc.texture.clear_color.w,
+    d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS  * (memory_desc.texture.initial_layout == G_TextureLayout_Simultaneous);
+    clear_value.Color[0] = memory_desc.texture.clear_color.x,
+    clear_value.Color[1] = memory_desc.texture.clear_color.y,
+    clear_value.Color[2] = memory_desc.texture.clear_color.z,
+    clear_value.Color[3] = memory_desc.texture.clear_color.w,
     clear_value.Format = d3d_desc.Format;
   }
 
@@ -1513,23 +1568,17 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 
   resource->flags = flags;
 
-  if (is_buffer)
-  {
-    resource->buffer_size         = desc.buffer.size;
-    resource->buffer_size_actual  = d3d_desc.Width;
-  }
-
   if (is_texture)
   {
-    resource->is_texture      = is_texture;
-    resource->texture_format  = desc.texture.format;
-    resource->texture_dims    = desc.texture.dims;
-    resource->texture_mips    = d3d_desc.MipLevels;
+    resource->is_texture = 1;
+    resource->texture_format = memory_desc.texture.format;
+    resource->texture_dims = memory_desc.texture.dims;
+    resource->texture_mips = d3d_desc.MipLevels;
   }
 
   if (is_sampler)
   {
-    resource->sampler_desc = desc.sampler;
+    resource->sampler_desc = memory_desc.sampler;
   }
 
   DllQueuePush(gpu_arena->resources.first, gpu_arena->resources.last, resource);
@@ -1550,7 +1599,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
     if (is_texture)
     {
       d3d_initial_layout = D3D12_BARRIER_LAYOUT_COMMON;
-      if (desc.texture.initial_layout == G_Layout_Exclusive)
+      if (memory_desc.texture.initial_layout == G_TextureLayout_Family)
       {
         switch (queue_kind)
         {
@@ -1578,7 +1627,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 
     // Queue initial Rtv/Dsv discard
     if (
-      !AnyBit(flags, G_MemoryFlag_ZeroMemory) &&
+      !AnyBit(flags, G_MemoryFlag_Zero) &&
       AnyBit(d3d_desc.Flags, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
     )
     {
@@ -1627,41 +1676,62 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
   }
 
   //////////////////////////////
-  //- Transition reused resources to common
+  //- Push ref
+
+
+
+  G_BaseDescriptorIndex result = 0;
+
+
+  // G_D12_RefBundle *bundle = 0;
+  // {
+  //   G_D12_RefBundleDesc memory_desc = Zi;
+  //   memory_desc.resource = resource;
+  //   if (is_buffer)
+  //   {
+  //     memory_desc.buffer_element_offset = 0;
+  //     memory_desc.buffer_element_count = memory_desc.buffer.count;
+  //     memory_desc.buffer_element_stride = memory_desc.buffer.stride;
+  //   }
+  //   else if (is_texture)
+  //   {
+  //     memory_desc.mips = RngI32(0, resource->texture_mips);
+  //   }
+
+  //   bundle = G_D12_PushRefBundle(cl, gpu_arena, memory_desc);
+  // }
+
+
+
+
+
+  //////////////////////////////
+  //- Transition reused texture to common if necessary
+
+
+
+  // FIXME: On reset, transition resources to UNDEFINED + No access
+  // Then here, transition from undefined (w/ discard if rt/dsv)
+
+
 
-  G_ResourceHandle resource_handle = G_D12_MakeHandle(G_ResourceHandle, resource);
   if (
+    is_texture &&
     can_reuse &&
-    desc.texture.initial_layout == G_Layout_Common &&
+    memory_desc.texture.initial_layout == G_TextureLayout_Common &&
     queue_kind != G_QueueKind_AsyncCopy
   )
   {
-    G_SyncLayout(cl_handle, resource_handle, G_Layout_Common);
-  }
 
-  //////////////////////////////
-  //- Push ref
-
-  G_D12_RefBundle *bundle = 0;
-  {
-    G_D12_RefBundleDesc desc = Zi;
-    desc.resource = resource;
-    if (is_buffer)
-    {
-      desc.buffer_element_offset = 0;
-      desc.buffer_element_count = desc.buffer.count;
-      desc.buffer_element_stride = desc.buffer.stride;
-    }
-    else if (is_texture)
-    {
-      desc.mips = RngI32(0, resource->texture_mips);
-    }
-
-    bundle = G_D12_PushRefBundle(cl, gpu_arena, desc);
+    G_SyncLayout(cl_handle, G_MakeTextureRef(result), G_TextureLayout_Common);
   }
 
 
-  return bundle->base_index;
+
+
+
+
+  return result;
 }
 
 
@@ -1715,13 +1785,13 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 //     // Heap flags
 //     if (flags & G_MemoryFlag_HostMemory)
 //     {
-//       heap_kind = G_D12_ResourceHeapKind_Cpu;
+//       heap_kind = G_D12_ResourceHeapKind_CpuWriteBack;
 //       if (flags & G_MemoryFlag_Uncached)
 //       {
 //         heap_kind = G_D12_ResourceHeapKind_CpuWriteCombined;
 //       }
 //     }
-//     if (flags & G_MemoryFlag_ZeroMemory)
+//     if (flags & G_MemoryFlag_Zero)
 //     {
 //       can_reuse = 0;
 //     }
@@ -1730,7 +1800,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 //       heap_flags |= D3D12_HEAP_FLAG_CREATE_NOT_ZEROED;
 //     }
 //     // Heap props
-//     if (heap_kind == G_D12_ResourceHeapKind_Cpu)
+//     if (heap_kind == G_D12_ResourceHeapKind_CpuWriteBack)
 //     {
 //       heap_props.Type = D3D12_HEAP_TYPE_CUSTOM;
 //       heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_WRITE_BACK;
@@ -1789,7 +1859,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 //     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS     * AnyBit(flags, G_MemoryFlag_AllowShaderReadWrite);
 //     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET        * AnyBit(flags, G_MemoryFlag_AllowRenderTarget);
 //     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL        * AnyBit(flags, G_MemoryFlag_AllowTextureDepthStencil);
-//     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS  * (desc.texture.initial_layout == G_Layout_Simultaneous);
+//     d3d_desc.Flags                |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS  * (desc.texture.initial_layout == G_TextureLayout_Simultaneous);
 //     clear_value.Color[0] = desc.texture.clear_color.x,
 //     clear_value.Color[1] = desc.texture.clear_color.y,
 //     clear_value.Color[2] = desc.texture.clear_color.z,
@@ -1903,7 +1973,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 //     if (is_texture)
 //     {
 //       d3d_initial_layout = D3D12_BARRIER_LAYOUT_COMMON;
-//       if (desc.texture.initial_layout == G_Layout_Exclusive)
+//       if (desc.texture.initial_layout == G_TextureLayout_Family)
 //       {
 //         switch (queue_kind)
 //         {
@@ -1931,7 +2001,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 
 //     // Queue initial Rtv/Dsv discard
 //     if (
-//       !AnyBit(flags, G_MemoryFlag_ZeroMemory) &&
+//       !AnyBit(flags, G_MemoryFlag_Zero) &&
 //       AnyBit(d3d_desc.Flags, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
 //     )
 //     {
@@ -1985,11 +2055,11 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 //   G_ResourceHandle resource_handle = G_D12_MakeHandle(G_ResourceHandle, resource);
 //   if (
 //     can_reuse &&
-//     desc.texture.initial_layout == G_Layout_Common &&
+//     desc.texture.initial_layout == G_TextureLayout_Common &&
 //     queue_kind != G_QueueKind_AsyncCopy
 //   )
 //   {
-//     G_SyncLayout(cl_handle, resource_handle, G_Layout_Common);
+//     G_SyncLayout(cl_handle, resource_handle, G_TextureLayout_Common);
 //   }
 
 //   return resource_handle;
@@ -2210,6 +2280,13 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
 
 //- Count
 
+u64 G_GetBufferStride(G_BufferRef buffer)
+{
+  // FIXME: Impl
+  u64 result = Zi;
+  return result;
+}
+
 u64 G_CountBuffer(G_BufferRef buffer)
 {
   // FIXME: Impl
@@ -2275,7 +2352,7 @@ i32 G_CountMips(G_TextureRef texture)
 
 //- Map
 
-void *G_CpuAddressFromBuffer(G_BufferRef buffer)
+void *G_CpuPointerFromBuffer(G_BufferRef buffer)
 {
   // FIXME: Impl
   void *result = 0;
@@ -2419,7 +2496,7 @@ G_D12_StagingRegionNode *G_D12_PushStagingRegion(G_D12_CmdList *cl, u64 size)
           u8, new_ring_size,
           .flags = G_MemoryFlag_HostUncached
         );
-        ring->base = G_StructFromBuffer(ring->buffer, u8);
+        ring->base = G_Deref(ring->buffer, u8);
       }
 
       // Create initial region
@@ -2827,7 +2904,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
         for (u32 rt_idx = 0; rt_idx < G_MaxRenderTargets; ++rt_idx)
         {
           G_RenderTargetDesc *rt_desc = &cmd->draw.render_target_descs[rt_idx];
-          G_D12_Resource *resource = G_D12_ResourceFromHandle(rt_desc->resource);
+          G_D12_Resource *resource = G_D12_ResourceFromTextureRef(rt_desc->texture);
           if (resource)
           {
             batch->contains_rtv = 1;
@@ -2876,7 +2953,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
           DllQueuePush(first_batch, last_batch, batch);
         }
 
-        G_D12_Resource *resource = cmd->barrier.resource;
+        G_D12_Resource *resource = G_D12_ResourceFromTextureRef(cmd->barrier.texture);
         if (resource)
         {
           if (cmd->barrier.acquire)
@@ -3266,7 +3343,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
               for (u32 i = 0; i < countof(cmd->draw.render_target_descs); ++i)
               {
                 G_RenderTargetDesc desc = cmd->draw.render_target_descs[i];
-                G_D12_Resource *rt = G_D12_ResourceFromHandle(desc.resource);
+                G_D12_Resource *rt = G_D12_ResourceFromTextureRef(desc.texture);
                 if (rt)
                 {
                   pipeline_desc.render_target_formats[i] = rt->texture_format;
@@ -3281,27 +3358,27 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
             }
 
             // Create ibv
-            u32 indices_count = 0;
+            u32 indices_count = G_CountBuffer(cmd->draw.indices);
             D3D12_INDEX_BUFFER_VIEW ibv = Zi;
             {
-              G_IndexBufferDesc desc = cmd->draw.index_buffer_desc;
-              if (desc.count > 0)
+              if (indices_count > 0)
               {
-                G_D12_Resource *index_buffer_resource = G_D12_ResourceFromHandle(desc.resource);
-                ibv.BufferLocation = index_buffer_resource->buffer_gpu_address;
-                ibv.SizeInBytes = desc.stride * desc.count;
-                if (desc.stride == 2)
+                G_D12_Resource *indices_resource = G_D12_ResourceFromBufferRef(cmd->draw.indices);
+                u32 stride = G_GetStride(cmd->draw.indices);
+                ibv.BufferLocation = indices_resource->buffer_gpu_address;
+                ibv.SizeInBytes = indices_count * stride;
+                if (stride == 2)
                 {
                   ibv.Format = DXGI_FORMAT_R16_UINT;
-                  indices_count = ibv.SizeInBytes / 2;
                 }
-                else if (desc.stride == 4)
+                else if (stride == 4)
                 {
                   ibv.Format = DXGI_FORMAT_R32_UINT;
-                  indices_count = ibv.SizeInBytes / 4;
                 }
                 else
                 {
+                  indices_count = 0;
+                  ZeroStruct(&ibv);
                   Assert(0);  // Invalid index size
                 }
               }
@@ -3411,14 +3488,14 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
                 for (u32 i = 0; i < countof(cmd->draw.render_target_descs); ++i)
                 {
                   G_RenderTargetDesc desc = cmd->draw.render_target_descs[i];
-                  G_D12_Resource *rt = G_D12_ResourceFromHandle(desc.resource);
+                  G_D12_Resource *rt = G_D12_ResourceFromTextureRef(desc.texture);
                   if (rt)
                   {
                     Assert(AnyBit(rt->d3d_desc.Flags, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET));
                     if (bound_render_target_uids[i] != rt->uid + desc.mip)
                     {
                       G_D12_Descriptor *rtv_descriptor = rcl->rtv_descriptors[i];
-                      G_D12_InitRtv(rt, rtv_descriptor->first_handle, desc.mip);
+                      G_D12_InitRtvDescriptorFromResource(rtv_descriptor, rt, desc.mip);
                       bound_render_target_uids[i] = rt->uid + desc.mip;
                       om_dirty = 1;
                     }
@@ -3434,7 +3511,7 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
                   D3D12_CPU_DESCRIPTOR_HANDLE rtv_handles[G_MaxRenderTargets] = Zi;
                   for (u32 i = 0; i < rtvs_count; ++i)
                   {
-                    rtv_handles[i] = rcl->rtv_descriptors[i]->first_handle;
+                    rtv_handles[i] = rcl->rtv_descriptors[i]->d3d_handle;
                   }
                   ID3D12GraphicsCommandList_OMSetRenderTargets(d3d_cl, rtvs_count, rtv_handles, 0, 0);
                 }
@@ -3458,14 +3535,14 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
               clear_color[2] = cmd->clear_rtv.color.z;
               clear_color[3] = cmd->clear_rtv.color.w;
             }
-            D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = rcl->rtv_clear_descriptor->first_handle;
+            G_D12_Descriptor *descriptor = rcl->rtv_clear_descriptor;
             if (bound_render_clear_target_uid != resource->uid + cmd->clear_rtv.mip)
             {
-              G_D12_InitRtv(resource, rtv_handle, cmd->clear_rtv.mip);
+              G_D12_InitRtvDescriptor(descriptor, resource, cmd->clear_rtv.mip);
               bound_render_clear_target_uid = resource->uid + cmd->clear_rtv.mip;
             }
             G_D12_InsertEvent(d3d_cl, G_D12_EventKind_Marker, STRING(resource->name_len, (u8 *)resource->name_cstr));
-            ID3D12GraphicsCommandList_ClearRenderTargetView(d3d_cl, rtv_handle, clear_color, 0, 0);
+            ID3D12GraphicsCommandList_ClearRenderTargetView(d3d_cl, descriptor->d3d_handle, clear_color, 0, 0);
           } break;
 
           //- Discard
@@ -3501,18 +3578,19 @@ i64 G_CommitCommandList(G_CommandListHandle cl_handle)
   //////////////////////////////
   //- Attach completion info to reset descriptors
 
-  for (G_D12_Descriptor *d = cl->reset_descriptors.first; d;)
+  for (G_D12_Descriptor *descriptor = cl->reset_descriptors.first; descriptor; descriptor = descriptor->next)
   {
-    G_D12_Descriptor *next = d->next;
+    G_D12_Descriptor *next = descriptor->next;
     {
-      G_D12_Arena *gpu_arena = d->gpu_arena;
-      d->completion_queue_kind = queue_kind;
-      d->completion_queue_target = completion_target;
-      G_D12_DescriptorList *gpu_arena_reset_descriptors_list = &gpu_arena->reset_descriptors_by_heap[d->heap->kind];
-      DllQueuePush(gpu_arena_reset_descriptors_list->first, gpu_arena_reset_descriptors_list->last, d);
-      ++gpu_arena_reset_descriptors_list->count;
+      G_D12_Arena *gpu_arena = descriptor->gpu_arena;
+      descriptor->completion_queue_kind = queue_kind;
+      descriptor->completion_queue_target = completion_target;
+      G_D12_DescriptorTable *dst_table = &gpu_arena->reset_descriptor_tables_by_heap[descriptor->heap->kind];
+      G_D12_DescriptorList *dst_list = &dst_table->descriptors_by_bundle_count[descriptor->bundle_count];
+      DllQueuePush(dst_list->first, dst_list->last, descriptor);
+      ++dst_list->count;
     }
-    d = next;
+    descriptor = next;
   }
 
   //////////////////////////////
@@ -3604,7 +3682,7 @@ void G_SyncLayout(G_CommandListHandle cl_handle, G_TextureRef texture, G_Texture
   G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
   G_D12_Cmd *cmd = G_D12_PushCmd(cl);
   cmd->kind = G_D12_CmdKind_Barrier;
-  cmd->barrier.resource = G_ResourceFromRef(texture);
+  cmd->barrier.texture = texture;
   cmd->barrier.acquire = layout == G_TextureLayout_Family;
 }
 
@@ -3628,7 +3706,7 @@ void G_PopZoneEx(G_CommandListHandle cl_handle)
 
 //- Cpu -> Gpu staged copy
 
-void G_CopyCpuToBuffer(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, u64 dst_offset, void *src, RngU64 src_copy_range)
+void G_CopyCpuToBuffer(G_CommandListHandle cl_handle, G_BufferRef dst, u64 dst_offset, void *src, RngU64 src_copy_range)
 {
   if (src_copy_range.max > src_copy_range.min)
   {
@@ -3638,15 +3716,15 @@ void G_CopyCpuToBuffer(G_CommandListHandle cl_handle, G_ResourceHandle dst_handl
     CopyBytes((u8 *)region->ring->base + region->pos, (u8 *)src + src_copy_range.min, copy_size);
     G_CopyBufferToBuffer(
       cl_handle,
-      dst_handle,
+      dst,
       dst_offset,
-      G_D12_MakeHandle(G_ResourceHandle, region->ring->resource),
+      region->ring->buffer,
       RNGU64(region->pos, region->pos + copy_size)
     );
   }
 }
 
-void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, Vec3I32 dst_offset, void *src, Vec3I32 src_dims, Rng3I32 src_copy_range)
+void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_TextureRef dst, Vec3I32 dst_offset, void *src, Vec3I32 src_dims, Rng3I32 src_copy_range)
 {
   Vec3I32 staged_dims = Zi;
   {
@@ -3657,8 +3735,8 @@ void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_hand
   if (staged_dims.x > 0 && staged_dims.y > 0 && staged_dims.z > 0)
   {
     G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
-    G_D12_Resource *dst = G_D12_ResourceFromHandle(dst_handle);
-    Assert(dst->is_texture);
+    G_D12_Resource *dst_resource = G_D12_ResourceFromTextureRef(dst);
+    Assert(dst_resource->is_texture);
 
     // Grab footprint info
     u64 staging_footprint_rows_count = 0;
@@ -3669,7 +3747,7 @@ void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_hand
     {
       D3D12_RESOURCE_DESC src_desc = Zi;
       {
-        ID3D12Resource_GetDesc(dst->d3d_resource, &src_desc);
+        ID3D12Resource_GetDesc(dst_resource->d3d_resource, &src_desc);
         src_desc.Width            = staged_dims.x;
         src_desc.Height           = staged_dims.y;
         src_desc.DepthOrArraySize = staged_dims.z;
@@ -3682,8 +3760,8 @@ void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_hand
     u64 src_row_pitch = src_dims.x * bytes_per_texel;
 
     G_D12_StagingRegionNode *staging_region = G_D12_PushStagingRegion(cl, staging_footprint_size);
-    G_D12_Resource *staging_resource = staging_region->ring->resource;
-    G_ResourceHandle staging_resource_handle = G_D12_MakeHandle(G_ResourceHandle, staging_resource);
+    G_BufferRef staging_buffer = staging_region->ring->buffer;
+    G_D12_Resource *staging_resource = G_D12_ResourceFromBufferRef(staging_buffer);
     staging_footprint.Offset = staging_region->pos;
 
     // Fill staging buffer
@@ -3712,29 +3790,29 @@ void G_CopyCpuToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_hand
     dst_copy_range.p1.z = dst_copy_range.p0.z + staged_dims.z;
     G_CopyBufferToTexture(
       cl_handle,
-      dst_handle, dst_copy_range,
-      staging_resource_handle, staging_footprint.Offset
+      dst, dst_copy_range,
+      staging_buffer, staging_footprint.Offset
     );
   }
 }
 
 //- Gpu <-> Gpu copy
 
-void G_CopyBufferToBuffer(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, u64 dst_offset, G_ResourceHandle src_handle, RngU64 src_copy_range)
+void G_CopyBufferToBuffer(G_CommandListHandle cl_handle, G_BufferRef dst, u64 dst_offset, G_BufferRef src, RngU64 src_copy_range)
 {
   if (src_copy_range.max > src_copy_range.min)
   {
     G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
     G_D12_Cmd *cmd = G_D12_PushCmd(cl);
     cmd->kind = G_D12_CmdKind_CopyBytes;
-    cmd->copy_bytes.src = G_D12_ResourceFromHandle(src_handle);
-    cmd->copy_bytes.dst = G_D12_ResourceFromHandle(dst_handle);
+    cmd->copy_bytes.src = G_D12_ResourceFromBufferRef(src);
+    cmd->copy_bytes.dst = G_D12_ResourceFromBufferRef(dst);
     cmd->copy_bytes.dst_offset = dst_offset;
     cmd->copy_bytes.src_range = src_copy_range;
   }
 }
 
-void G_CopyBufferToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, Rng3I32 dst_copy_range, G_ResourceHandle src_handle, u64 src_offset)
+void G_CopyBufferToTexture(G_CommandListHandle cl_handle, G_TextureRef dst_ref, Rng3I32 dst_copy_range, G_BufferRef src_ref, u64 src_offset)
 {
   Vec3I32 src_dims = Zi;
   {
@@ -3745,8 +3823,8 @@ void G_CopyBufferToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_h
   if (src_dims.x > 0 && src_dims.y > 0 && src_dims.z > 0)
   {
     G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
-    G_D12_Resource *src = G_D12_ResourceFromHandle(src_handle);
-    G_D12_Resource *dst = G_D12_ResourceFromHandle(dst_handle);
+    G_D12_Resource *src = G_D12_ResourceFromBufferRef(src_ref);
+    G_D12_Resource *dst = G_D12_ResourceFromTextureRef(dst_ref);
     Assert(!src->is_texture);
     Assert(dst->is_texture);
 
@@ -3787,7 +3865,7 @@ void G_CopyBufferToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_h
   }
 }
 
-void G_CopyTextureToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, Vec3I32 dst_offset, G_ResourceHandle src_handle, Rng3I32 src_copy_range)
+void G_CopyTextureToTexture(G_CommandListHandle cl_handle, G_TextureRef dst_ref, Vec3I32 dst_offset, G_TextureRef src_ref, Rng3I32 src_copy_range)
 {
   if (
     src_copy_range.p1.x > src_copy_range.p0.x &&
@@ -3796,8 +3874,8 @@ void G_CopyTextureToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_
   )
   {
     G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
-    G_D12_Resource *src = G_D12_ResourceFromHandle(src_handle);
-    G_D12_Resource *dst = G_D12_ResourceFromHandle(dst_handle);
+    G_D12_Resource *src = G_D12_ResourceFromTextureRef(src_ref);
+    G_D12_Resource *dst = G_D12_ResourceFromTextureRef(dst_ref);
     Assert(src->is_texture);
     Assert(dst->is_texture);
 
@@ -3825,7 +3903,7 @@ void G_CopyTextureToTexture(G_CommandListHandle cl_handle, G_ResourceHandle dst_
   }
 }
 
-void G_CopyTextureToBuffer(G_CommandListHandle cl_handle, G_ResourceHandle dst_handle, Vec3I32 dst_offset, G_ResourceHandle src_handle, Rng3I32 src_copy_range)
+void G_CopyTextureToBuffer(G_CommandListHandle cl_handle, G_BufferRef dst, Vec3I32 dst_offset, G_TextureRef src, Rng3I32 src_copy_range)
 {
   // TODO
   Assert(0);
@@ -3850,13 +3928,13 @@ void G_ComputeEx(G_CommandListHandle cl_handle, ComputeShaderDesc cs, Vec3I32 th
 void G_Draw(
   G_CommandListHandle cl_handle,
   VertexShaderDesc vs, PixelShaderDesc ps,
-  u32 instances_count, G_IndexBufferDesc index_buffer,
+  u32 instances_count, G_BufferRef indices,
   u32 render_targets_count, G_RenderTargetDesc *render_targets,
   Rng3 viewport, Rng2 scissor,
   G_DrawMode draw_mode
 )
 {
-  if (instances_count > 0 && index_buffer.count > 0)
+  if (instances_count > 0 && G_CountBuffer(indices) > 0)
   {
     G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
     G_D12_Cmd *cmd = G_D12_PushCmd(cl);
@@ -3864,7 +3942,7 @@ void G_Draw(
     cmd->draw.vs = vs;
     cmd->draw.ps = ps;
     cmd->draw.instances_count = instances_count;
-    cmd->draw.index_buffer_desc = index_buffer;
+    cmd->draw.indices = indices;
     for (u32 rt_idx = 0; rt_idx < MinU32(render_targets_count, G_MaxRenderTargets); ++rt_idx)
     {
       cmd->draw.render_target_descs[rt_idx] = render_targets[rt_idx];
@@ -3877,12 +3955,12 @@ void G_Draw(
 
 //- Clear
 
-void G_ClearRenderTarget(G_CommandListHandle cl_handle, G_ResourceHandle resource_handle, Vec4 color, i32 mip)
+void G_ClearRenderTarget(G_CommandListHandle cl_handle, G_TextureRef texture, Vec4 color, i32 mip)
 {
   G_D12_CmdList *cl = G_D12_CmdListFromHandle(cl_handle);
   G_D12_Cmd *cmd = G_D12_PushCmd(cl);
   cmd->kind = G_D12_CmdKind_ClearRtv;
-  cmd->clear_rtv.resource = G_D12_ResourceFromHandle(resource_handle);
+  cmd->clear_rtv.resource = G_D12_ResourceFromTextureRef(texture);
   cmd->clear_rtv.color = color;
   cmd->clear_rtv.mip = mip;
 }
@@ -4036,7 +4114,7 @@ void G_ReleaseSwapchain(G_SwapchainHandle swapchain_handle)
   // TODO
 }
 
-G_ResourceHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format format, Vec2I32 size)
+G_TextureRef G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Format format, Vec2I32 size)
 {
   G_D12_Swapchain *swapchain = G_D12_SwapchainFromHandle(swapchain_handle);
   TempArena scratch = BeginScratchNoConflict();
@@ -4162,7 +4240,7 @@ G_ResourceHandle G_PrepareBackbuffer(G_SwapchainHandle swapchain_handle, G_Forma
           Panic(Lit("Failed to retrieve swapchain buffer"));
         }
         ZeroStruct(backbuffer);
-        backbuffer->flags = G_MemoryFlag_AllowRenderTarget;
+        backbuffer->flags = G_MemoryFlag_AllowTextureDraw;
         backbuffer->uid = Atomic64FetchAdd(&G_D12.resource_creation_gen.v, 1) + 1;
 
         ID3D12Resource_GetDesc(d3d_resource, (D3D12_RESOURCE_DESC *)&backbuffer->d3d_desc);
@@ -4310,10 +4388,11 @@ void G_D12_CollectionWorkerEntryPoint(WaveLaneCtx *lane)
       G_D12_Queue *queue = G_D12_QueueFromKind(queue_kind);
       if (!G_IsResourceNil(queue->print_buffer))
       {
-        u32 attempted_print_bytes_count = *(G_StructFromResource(queue->print_readback_buffer, u32) + 0);  // The number of bytes shaders attempted to write
-        u32 prints_count                = *(G_StructFromResource(queue->print_readback_buffer, u32) + 1);  // The number of shader prints that are in the buffer
-        u32 overflows_count             = *(G_StructFromResource(queue->print_readback_buffer, u32) + 2);  // The number of shader prints that could not fit in the buffer
-        u8 *start                       = G_StructFromResource(queue->print_readback_buffer, u8) + 12;
+        u32 header = G_Deref(queue->print_readback_buffer, u32);
+        u32 attempted_print_bytes_count = header[0];  // The number of bytes that shaders attempted to write
+        u32 prints_count                = header[1];  // The number of individual shader prints that are in the buffer
+        u32 overflows_count             = header[2];  // The number of individual shader prints that could not fit in the buffer
+        u8 *start                       = &header[3];
 
         // Deserialize
         if (GPU_SHADER_PRINT_LOG)
diff --git a/src/gpu/gpu_dx12/gpu_dx12_core.h b/src/gpu/gpu_dx12/gpu_dx12_core.h
index 2ccd501f..6b1a3e35 100644
--- a/src/gpu/gpu_dx12/gpu_dx12_core.h
+++ b/src/gpu/gpu_dx12/gpu_dx12_core.h
@@ -81,10 +81,6 @@ Struct(G_D12_Resource)
   D3D12_GPU_VIRTUAL_ADDRESS buffer_gpu_address;
   void *mapped;
 
-  // Buffer info
-  u64 buffer_size;
-  u64 buffer_size_actual;
-
   // Texture info
   b32 is_texture;
   G_Format texture_format;
@@ -141,38 +137,35 @@ Struct(G_D12_DescriptorHeap)
   struct G_D12_Descriptor *first_free_descriptor_by_count[G_D12_MaxDescriptorBundleCount];
 };
 
-Struct(G_D12_DescriptorDesc)
+Struct(G_D12_Descriptor)
 {
+  G_D12_Descriptor *next;
+  G_D12_Descriptor *prev;
+
+  // Persistent data
+
+  G_D12_DescriptorHeap *heap;
+  D3D12_CPU_DESCRIPTOR_HANDLE d3d_handle;
+  u32 base_index;
+
+  // Per-lifetime data
+
+  struct G_D12_Arena *gpu_arena;
   G_D12_Resource *resource;
 
-  u32 bundle_count;
+  u64 bundle_count;
 
   u64 buffer_element_offset;
   u64 buffer_element_count;
   u64 buffer_element_stride;
 
   RngI32 texture_mips;
-};
-
-Struct(G_D12_Descriptor)
-{
-  G_D12_Descriptor *next;
-  G_D12_Descriptor *prev;
-
-  // Static data
-
-  G_D12_DescriptorHeap *heap;
-  u32 base_index;
-
-  // Per-lifetime data
-
-  struct G_D12_Arena *gpu_arena;
-  G_D12_DescriptorDesc desc;
 
   G_QueueKind completion_queue_kind;
   i64 completion_queue_target;
 };
 
+
 Struct(G_D12_DescriptorList)
 {
   u64 count;
@@ -180,18 +173,18 @@ Struct(G_D12_DescriptorList)
   G_D12_Descriptor *last;
 };
 
+Struct(G_D12_DescriptorTable)
+{
+  G_D12_DescriptorList descriptors_by_bundle_count[G_D12_MaxDescriptorBundleCount];
+};
+
 ////////////////////////////////////////////////////////////
 //~ Arena types
 
-// TODO:
-// To support D3D12_RESOURCE_HEAP_TIER_1 devices, create separate heaps for:
-// - Buffers
-// - Non-render target & non-depth stencil textures
-// - Render target or depth stencil textures
 Enum(G_D12_ResourceHeapKind)
 {
   G_D12_ResourceHeapKind_Gpu,
-  G_D12_ResourceHeapKind_Cpu,
+  G_D12_ResourceHeapKind_CpuWriteBack,
   G_D12_ResourceHeapKind_CpuWriteCombined,
 
   G_D12_ResourceHeapKind_COUNT
@@ -202,11 +195,10 @@ Struct(G_D12_Arena)
   Arena *arena;
 
   G_D12_DescriptorList descriptors;
-  G_D12_DescriptorList reset_descriptors_by_heap[G_D12_DescriptorHeapKind_COUNT];
+  G_D12_DescriptorTable reset_descriptor_tables_by_heap[G_D12_DescriptorHeapKind_COUNT];
 
   G_D12_ResourceList resources;
   G_D12_ResourceList reset_resources;
-  // G_D12_ResourceList free_resources;
 };
 
 ////////////////////////////////////////////////////////////
@@ -223,7 +215,6 @@ Struct(G_D12_StagingRing)
 
   struct G_D12_StagingRegionNode *head_region_node;
   struct G_D12_StagingRegionNode *first_free_region_node;
-
 };
 
 Struct(G_D12_StagingRegionNode)
@@ -306,6 +297,22 @@ Struct(G_D12_Releasable)
   i64 completion_queue_target;
 
   ID3D12Resource *d3d_resource;
+
+
+
+
+
+
+
+
+
+  // FIXME: Release descriptors as well
+
+
+
+
+
+
 };
 
 Struct(G_D12_ReleasableList)
@@ -354,7 +361,7 @@ Struct(G_D12_Cmd)
 
     struct
     {
-      G_D12_Resource *resource;
+      G_TextureRef texture;
       b32 acquire;
     } barrier;
 
@@ -393,7 +400,7 @@ Struct(G_D12_Cmd)
       VertexShaderDesc vs;
       PixelShaderDesc ps;
       u32 instances_count;
-      G_IndexBufferDesc index_buffer_desc;
+      G_BufferRef indices;
       G_RenderTargetDesc render_target_descs[G_MaxRenderTargets];
       Rng3 viewport;
       Rng2 scissor;
@@ -705,14 +712,11 @@ DeclApiFromXList(G_D12_AgsApi, G_D12_AgsApiXList, "amd_ags_x64.dll");
 
 G_D12_Arena *G_D12_ArenaFromHandle(G_ArenaHandle handle);
 G_D12_CmdList *G_D12_CmdListFromHandle(G_CommandListHandle handle);
-G_D12_Resource *G_D12_ResourceFromHandle(G_ResourceHandle handle);
 G_D12_Swapchain *G_D12_SwapchainFromHandle(G_SwapchainHandle handle);
 
 DXGI_FORMAT G_D12_DxgiFormatFromGpuFormat(G_Format format);
 D3D12_BARRIER_LAYOUT G_D12_CommonLayoutFromQueueKind(G_QueueKind queue_kind);
 
-void G_D12_InitRtv(G_D12_Resource *resource, D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, i32 mip);
-
 void G_D12_SetObjectName(ID3D12Object *object, String name);
 String G_D12_NameFromObject(Arena *arena, ID3D12Object *object);
 
@@ -744,7 +748,9 @@ void G_D12_ResetArena(G_D12_CmdList *cl, G_D12_Arena *gpu_arena);
 // G_D12_Descriptor *G_D12_DescriptorFromIndex(G_D12_DescriptorHeapKind heap_kind, u32 index);
 // G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, G_D12_DescriptorHeapKind heap_kind);
 
-G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, G_D12_DescriptorDesc desc, G_D12_DescriptorHeapKind heap_kind);
+G_D12_Descriptor *G_D12_PushDescriptor(G_D12_Arena *gpu_arena, u64 bundle_count, G_D12_DescriptorHeapKind heap_kind);
+
+void G_D12_InitRtvDescriptor(G_D12_Descriptor *descriptor, G_D12_Resource *resource, i32 mip);
 
 ////////////////////////////////////////////////////////////
 //~ Command helpers
diff --git a/src/gpu/gpu_shared.cgh b/src/gpu/gpu_shared.cgh
index fe876934..e5ea0ef6 100644
--- a/src/gpu/gpu_shared.cgh
+++ b/src/gpu/gpu_shared.cgh
@@ -7,6 +7,14 @@ Struct(G_BufferRef)     { G_BaseDescriptorIndex v; };
 Struct(G_TextureRef)    { G_BaseDescriptorIndex v; };
 Struct(G_SamplerRef)    { G_BaseDescriptorIndex v; };
 
+#define G_MakeBufferRef(_v)  ((G_BufferRef)  { .v = (_v) })
+#define G_MakeTextureRef(_v) ((G_TextureRef) { .v = (_v) })
+#define G_MakeSamplerRef(_v) ((G_SamplerRef) { .v = (_v) })
+
+#define G_NilBufferRef  G_MakeBufferRef(0)
+#define G_NilTextureRef G_MakeTextureRef(0)
+#define G_NilSamplerRef G_MakeSamplerRef(0)
+
 #define G_IsRefNil(r) ((r).v == 0)
 
 ////////////////////////////////////////////////////////////
@@ -19,18 +27,18 @@ Struct(G_SamplerRef)    { G_BaseDescriptorIndex v; };
 //
 #define G_NumGeneralPurposeConstants    (24)  // Constants available for any usage
 #define G_NumReservedConstants          (4)   // Constants reserved for internal usage by the GPU layer
-#define G_NumConstants (G_NumGeneralPurposeConstants + G_NumReservedConstants)
+#define G_NumConstants                  (G_NumGeneralPurposeConstants + G_NumReservedConstants)
 
 #if IsCpu
   #define G_ForceDeclConstant(type, name, slot)                   \
     enum { name = slot };                                         \
-    Struct(name##__shaderconstanttype) { type v; }
+    Struct(CAT(__ShaderConstantType_,name)) { type v; }
   #define G_DeclConstant(type, name, slot)                        \
     StaticAssert(sizeof(type) <= 4);                              \
     StaticAssert(slot < G_NumGeneralPurposeConstants);            \
     G_ForceDeclConstant(type, name, slot)
 #else
-  #define G_ForceDeclConstant(type, name, slot) cbuffer name : register(b##slot) { type name; }
+  #define G_ForceDeclConstant(type, name, slot) cbuffer name : register(CAT(b,slot)) { type name; }
   #define G_DeclConstant(type, name, slot) G_ForceDeclConstant(type, name, slot)
 #endif