diff --git a/src/microsoft/vulkan/dzn_cmd_buffer.cpp b/src/microsoft/vulkan/dzn_cmd_buffer.cpp
index d8718954fec..e342d3d6361 100644
--- a/src/microsoft/vulkan/dzn_cmd_buffer.cpp
+++ b/src/microsoft/vulkan/dzn_cmd_buffer.cpp
@@ -38,14 +38,14 @@ dzn_cmd_buffer_destroy(struct vk_command_buffer *cbuf)
    dzn_device *device = container_of(cbuf->base.device, dzn_device, vk);
 
    if (cmdbuf->cmdlist)
-      cmdbuf->cmdlist->Release();
+      ID3D12GraphicsCommandList1_Release(cmdbuf->cmdlist);
 
    if (cmdbuf->cmdalloc)
-      cmdbuf->cmdalloc->Release();
+      ID3D12CommandAllocator_Release(cmdbuf->cmdalloc);
 
    list_for_each_entry_safe(dzn_internal_resource, res, &cmdbuf->internal_bufs, link) {
       list_del(&res->link);
-      res->res->Release();
+      ID3D12Resource_Release(res->res);
       vk_free(&cbuf->pool->alloc, res);
    }
 
@@ -181,15 +181,17 @@ dzn_cmd_buffer_create(const VkCommandBufferAllocateInfo *info,
 
    cmdbuf->vk.destroy = dzn_cmd_buffer_destroy;
 
-   if (FAILED(device->dev->CreateCommandAllocator(type,
-                                                  IID_PPV_ARGS(&cmdbuf->cmdalloc)))) {
+   if (FAILED(ID3D12Device1_CreateCommandAllocator(device->dev, type,
+                                                   IID_ID3D12CommandAllocator,
+                                                   (void **)&cmdbuf->cmdalloc))) {
       result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
 
-   if (FAILED(device->dev->CreateCommandList(0, type,
-                                             cmdbuf->cmdalloc, NULL,
-                                             IID_PPV_ARGS(&cmdbuf->cmdlist)))) {
+   if (FAILED(ID3D12Device1_CreateCommandList(device->dev, 0, type,
+                                              cmdbuf->cmdalloc, NULL,
+                                              IID_ID3D12GraphicsCommandList1,
+                                              (void **)&cmdbuf->cmdlist))) {
       result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
@@ -217,7 +219,7 @@ dzn_cmd_buffer_reset(dzn_cmd_buffer *cmdbuf)
    /* TODO: Return resources to the pool */
    list_for_each_entry_safe(dzn_internal_resource, res, &cmdbuf->internal_bufs, link) {
       list_del(&res->link);
-      res->res->Release();
+      ID3D12Resource_Release(res->res);
       vk_free(&cmdbuf->vk.pool->alloc, res);
    }
 
@@ -255,14 +257,16 @@ dzn_cmd_buffer_reset(dzn_cmd_buffer *cmdbuf)
     * cmdlist allocated from the allocator, so we need to release and create
     * a new command list.
     */
-   cmdbuf->cmdlist->Release();
+   ID3D12GraphicsCommandList1_Release(cmdbuf->cmdlist);
    cmdbuf->cmdlist = NULL;
-   cmdbuf->cmdalloc->Reset();
+   ID3D12CommandAllocator_Reset(cmdbuf->cmdalloc);
    D3D12_COMMAND_LIST_TYPE type =
       pdev->queue_families[pool->queue_family_index].desc.Type;
-   if (FAILED(device->dev->CreateCommandList(0, type,
-                                             cmdbuf->cmdalloc, NULL,
-                                             IID_PPV_ARGS(&cmdbuf->cmdlist)))) {
+   if (FAILED(ID3D12Device1_CreateCommandList(device->dev, 0,
+                                              type,
+                                              cmdbuf->cmdalloc, NULL,
+                                              IID_ID3D12GraphicsCommandList1,
+                                              (void **)&cmdbuf->cmdlist))) {
       cmdbuf->error = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
 
@@ -526,10 +530,12 @@ dzn_cmd_buffer_collect_queries(dzn_cmd_buffer *cmdbuf,
         __bitset_next_range(&start, &end, collect, nbits);
         start < nbits;
         __bitset_next_range(&start, &end, collect, nbits)) {
-      cmdbuf->cmdlist->ResolveQueryData(qpool->heap, qpool->queries[start].type,
-                                        start, end - start,
-                                        qpool->resolve_buffer,
-                                        qpool->query_size * start);
+      ID3D12GraphicsCommandList1_ResolveQueryData(cmdbuf->cmdlist,
+                                                  qpool->heap,
+                                                  qpool->queries[start].type,
+                                                  start, end - start,
+                                                  qpool->resolve_buffer,
+                                                  qpool->query_size * start);
    }
 
    D3D12_RESOURCE_BARRIER barrier = {
@@ -544,11 +550,12 @@ dzn_cmd_buffer_collect_queries(dzn_cmd_buffer *cmdbuf,
    uint32_t offset = dzn_query_pool_get_result_offset(qpool, first_query);
    uint32_t size = dzn_query_pool_get_result_size(qpool, query_count);
 
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 
-   cmdbuf->cmdlist->CopyBufferRegion(qpool->collect_buffer, offset,
-                                     qpool->resolve_buffer, offset,
-                                     size);
+   ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist,
+                                               qpool->collect_buffer, offset,
+                                               qpool->resolve_buffer, offset,
+                                               size);
 
    for (start = first_query, end = first_query,
         __bitset_next_range(&start, &end, collect, nbits);
@@ -560,11 +567,12 @@ dzn_cmd_buffer_collect_queries(dzn_cmd_buffer *cmdbuf,
       for (unsigned i = 0; i < count; i+= step) {
          uint32_t sub_count = MIN2(step, count - i);
 
-         cmdbuf->cmdlist->CopyBufferRegion(qpool->collect_buffer,
-                                           dzn_query_pool_get_availability_offset(qpool, start + i),
-                                           device->queries.refs,
-                                           DZN_QUERY_REFS_ALL_ONES_OFFSET,
-                                           sizeof(uint64_t) * sub_count);
+         ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist,
+                                                     qpool->collect_buffer,
+                                                     dzn_query_pool_get_availability_offset(qpool, start + i),
+                                                     device->queries.refs,
+                                                     DZN_QUERY_REFS_ALL_ONES_OFFSET,
+                                                     sizeof(uint64_t) * sub_count);
       }
 
       dzn_cmd_buffer_dynbitset_set_range(cmdbuf, &state->signal, start, count);
@@ -572,7 +580,7 @@ dzn_cmd_buffer_collect_queries(dzn_cmd_buffer *cmdbuf,
    }
 
    DZN_SWAP(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
    return VK_SUCCESS;
 }
 
@@ -639,7 +647,7 @@ dzn_EndCommandBuffer(VkCommandBuffer commandBuffer)
    if (cmdbuf->vk.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
       dzn_cmd_buffer_gather_events(cmdbuf);
       dzn_cmd_buffer_gather_queries(cmdbuf);
-      HRESULT hres = cmdbuf->cmdlist->Close();
+      HRESULT hres = ID3D12GraphicsCommandList1_Close(cmdbuf->cmdlist);
       if (FAILED(hres))
          cmdbuf->error = vk_error(cmdbuf->vk.base.device, VK_ERROR_OUT_OF_HOST_MEMORY);
    } else {
@@ -671,7 +679,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
          .UAV = { .pResource = NULL },
       };
 
-      cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
    }
 
    /* Global memory barriers can be emulated with NULL UAV/Aliasing barriers.
@@ -688,7 +696,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
       barriers[1].Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
       barriers[1].Aliasing.pResourceBefore = NULL;
       barriers[1].Aliasing.pResourceAfter = NULL;
-      cmdbuf->cmdlist->ResourceBarrier(2, barriers);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 2, barriers);
    }
 
    for (uint32_t i = 0; i < info->bufferMemoryBarrierCount; i++) {
@@ -702,7 +710,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
       barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
       barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
       barrier.UAV.pResource = buf->res;
-      cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
    }
 
    for (uint32_t i = 0; i < info->imageMemoryBarrierCount; i++) {
@@ -723,7 +731,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
          },
       };
 
-      cmdbuf->cmdlist->ResourceBarrier(1, &aliasing_barrier);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &aliasing_barrier);
 
       dzn_foreach_aspect(aspect, range->aspectMask) {
          D3D12_RESOURCE_BARRIER transition_barrier = {
@@ -753,7 +761,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
             for (uint32_t lvl = 0; lvl < level_count; lvl++) {
                transition_barrier.Transition.Subresource =
                   dzn_image_range_get_subresource_index(image, range, aspect, lvl, layer);
-               cmdbuf->cmdlist->ResourceBarrier(1, &transition_barrier);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &transition_barrier);
             }
          }
       }
@@ -781,7 +789,7 @@ dzn_cmd_buffer_get_dsv(dzn_cmd_buffer *cmdbuf,
       dsve->key = key;
       dzn_descriptor_heap_pool_alloc_slots(&cmdbuf->dsvs.pool, device, 1, &heap, &slot);
       dsve->handle = dzn_descriptor_heap_get_cpu_handle(heap, slot);
-      device->dev->CreateDepthStencilView(image->res, desc, dsve->handle);
+      ID3D12Device1_CreateDepthStencilView(device->dev, image->res, desc, dsve->handle);
       _mesa_hash_table_insert(cmdbuf->dsvs.ht, &dsve->key, dsve);
    } else {
       dsve = (dzn_cmd_buffer_dsv_entry *)he->data;
@@ -811,7 +819,7 @@ dzn_cmd_buffer_get_rtv(dzn_cmd_buffer *cmdbuf,
       rtve->key = key;
       dzn_descriptor_heap_pool_alloc_slots(&cmdbuf->rtvs.pool, device, 1, &heap, &slot);
       rtve->handle = dzn_descriptor_heap_get_cpu_handle(heap, slot);
-      device->dev->CreateRenderTargetView(image->res, desc, rtve->handle);
+      ID3D12Device1_CreateRenderTargetView(device->dev, image->res, desc, rtve->handle);
       he = _mesa_hash_table_insert(cmdbuf->rtvs.ht, &rtve->key, rtve);
    } else {
       rtve = (dzn_cmd_buffer_rtv_entry *)he->data;
@@ -834,8 +842,8 @@ dzn_cmd_buffer_alloc_internal_buf(dzn_cmd_buffer *cmdbuf,
    /* Align size on 64k (the default alignment) */
    size = ALIGN_POT(size, 64 * 1024);
 
-   D3D12_HEAP_PROPERTIES hprops =
-      device->dev->GetCustomHeapProperties(0, heap_type);
+   D3D12_HEAP_PROPERTIES hprops;
+   ID3D12Device1_GetCustomHeapProperties(device->dev, &hprops, 0, heap_type);
    D3D12_RESOURCE_DESC rdesc = {
       .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
       .Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
@@ -850,9 +858,11 @@ dzn_cmd_buffer_alloc_internal_buf(dzn_cmd_buffer *cmdbuf,
    };
 
    HRESULT hres =
-      device->dev->CreateCommittedResource(&hprops, D3D12_HEAP_FLAG_NONE, &rdesc,
-                                           init_state,
-                                           NULL, IID_PPV_ARGS(&res));
+      ID3D12Device1_CreateCommittedResource(device->dev, &hprops,
+                                            D3D12_HEAP_FLAG_NONE, &rdesc,
+                                            init_state, NULL,
+                                            IID_ID3D12Resource,
+                                            (void **)&res);
    if (FAILED(hres)) {
       cmdbuf->error = vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
       return cmdbuf->error;
@@ -863,7 +873,7 @@ dzn_cmd_buffer_alloc_internal_buf(dzn_cmd_buffer *cmdbuf,
                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
    if (!entry) {
       cmdbuf->error = vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
-      res->Release();
+      ID3D12Resource_Release(res);
       return cmdbuf->error;
    }
 
@@ -918,11 +928,11 @@ dzn_cmd_buffer_clear_rects_with_copy(dzn_cmd_buffer *cmdbuf,
    assert(!(res_size % fill_step));
 
    uint8_t *cpu_ptr;
-   src_res->Map(0, NULL, (void **)&cpu_ptr);
+   ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
    for (uint32_t i = 0; i < res_size; i += fill_step)
       memcpy(&cpu_ptr[i], buf, fill_step);
 
-   src_res->Unmap(0, NULL);
+   ID3D12Resource_Unmap(src_res, 0, NULL);
 
    D3D12_TEXTURE_COPY_LOCATION src_loc = {
       .pResource = src_res,
@@ -950,7 +960,7 @@ dzn_cmd_buffer_clear_rects_with_copy(dzn_cmd_buffer *cmdbuf,
       },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 
    barrier.Transition.pResource = image->res;
 
@@ -971,7 +981,7 @@ dzn_cmd_buffer_clear_rects_with_copy(dzn_cmd_buffer *cmdbuf,
                dzn_image_range_get_subresource_index(image, range, aspect, 0, layer);
             barrier.Transition.StateBefore = dst_state;
             barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST;
-            cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+            ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
          }
 
          D3D12_TEXTURE_COPY_LOCATION dst_loc =
@@ -992,15 +1002,18 @@ dzn_cmd_buffer_clear_rects_with_copy(dzn_cmd_buffer *cmdbuf,
                .back = 1,
             };
 
-            cmdbuf->cmdlist->CopyTextureRegion(&dst_loc,
-                                               rects[r].left, rects[r].top, 0,
-                                               &src_loc, &src_box);
+            ID3D12GraphicsCommandList1_CopyTextureRegion(cmdbuf->cmdlist,
+                                                         &dst_loc,
+                                                         rects[r].left,
+                                                         rects[r].top, 0,
+                                                         &src_loc,
+                                                         &src_box);
          }
 
          if (dst_state != D3D12_RESOURCE_STATE_COPY_DEST) {
             barrier.Transition.StateAfter = dst_state;
             barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
-            cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+            ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
          }
       }
    }
@@ -1071,11 +1084,11 @@ dzn_cmd_buffer_clear_ranges_with_copy(dzn_cmd_buffer *cmdbuf,
    assert(!(res_size % fill_step));
 
    uint8_t *cpu_ptr;
-   src_res->Map(0, NULL, (void **)&cpu_ptr);
+   ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
    for (uint32_t i = 0; i < res_size; i += fill_step)
       memcpy(&cpu_ptr[i], buf, fill_step);
 
-   src_res->Unmap(0, NULL);
+   ID3D12Resource_Unmap(src_res, 0, NULL);
 
    D3D12_TEXTURE_COPY_LOCATION src_loc = {
       .pResource = src_res,
@@ -1097,7 +1110,7 @@ dzn_cmd_buffer_clear_ranges_with_copy(dzn_cmd_buffer *cmdbuf,
       },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 
    barrier.Transition.pResource = image->res;
    for (uint32_t r = 0; r < range_count; r++) {
@@ -1122,7 +1135,7 @@ dzn_cmd_buffer_clear_ranges_with_copy(dzn_cmd_buffer *cmdbuf,
                      dzn_image_range_get_subresource_index(image, &ranges[r], aspect, lvl, layer);
                   barrier.Transition.StateBefore = dst_state;
                   barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST;
-                  cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+                  ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
                }
 
                D3D12_TEXTURE_COPY_LOCATION dst_loc =
@@ -1146,13 +1159,13 @@ dzn_cmd_buffer_clear_ranges_with_copy(dzn_cmd_buffer *cmdbuf,
                   .back = d,
                };
 
-               cmdbuf->cmdlist->CopyTextureRegion(&dst_loc, 0, 0, 0,
+               ID3D12GraphicsCommandList1_CopyTextureRegion(cmdbuf->cmdlist, &dst_loc, 0, 0, 0,
                                                   &src_loc, &src_box);
 
                if (dst_state != D3D12_RESOURCE_STATE_COPY_DEST) {
                   barrier.Transition.StateAfter = dst_state;
                   barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST;
-                  cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+                  ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
                }
             }
          }
@@ -1199,7 +1212,7 @@ dzn_cmd_buffer_clear_attachment(dzn_cmd_buffer *cmdbuf,
       if (flags != 0) {
          auto desc = dzn_image_get_dsv_desc(image, &range, 0);
          auto handle = dzn_cmd_buffer_get_dsv(cmdbuf, image, &desc);
-         cmdbuf->cmdlist->ClearDepthStencilView(handle, flags,
+         ID3D12GraphicsCommandList1_ClearDepthStencilView(cmdbuf->cmdlist, handle, flags,
                                                 value->depthStencil.depth,
                                                 value->depthStencil.stencil,
                                                 rect_count, rects);
@@ -1238,7 +1251,7 @@ dzn_cmd_buffer_clear_attachment(dzn_cmd_buffer *cmdbuf,
       } else {
          auto desc = dzn_image_get_rtv_desc(image, &range, 0);
          auto handle = dzn_cmd_buffer_get_rtv(cmdbuf, image, &desc);
-         cmdbuf->cmdlist->ClearRenderTargetView(handle, vals, rect_count, rects);
+         ID3D12GraphicsCommandList1_ClearRenderTargetView(cmdbuf->cmdlist, handle, vals, rect_count, rects);
       }
    }
 }
@@ -1304,7 +1317,7 @@ dzn_cmd_buffer_clear_color(dzn_cmd_buffer *cmdbuf,
                   dzn_image_range_get_subresource_index(image, range,
                                                         VK_IMAGE_ASPECT_COLOR_BIT,
                                                         lvl, layer);
-               cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
             }
          }
 
@@ -1317,7 +1330,7 @@ dzn_cmd_buffer_clear_color(dzn_cmd_buffer *cmdbuf,
 
          auto desc = dzn_image_get_rtv_desc(image, &view_range, lvl);
          auto handle = dzn_cmd_buffer_get_rtv(cmdbuf, image, &desc);
-         cmdbuf->cmdlist->ClearRenderTargetView(handle, clear_vals, 0, NULL);
+         ID3D12GraphicsCommandList1_ClearRenderTargetView(cmdbuf->cmdlist, handle, clear_vals, 0, NULL);
 
          if (barrier.Transition.StateBefore != barrier.Transition.StateAfter) {
             DZN_SWAP(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
@@ -1325,7 +1338,7 @@ dzn_cmd_buffer_clear_color(dzn_cmd_buffer *cmdbuf,
             for (uint32_t layer = 0; layer < layer_count; layer++) {
                barrier.Transition.Subresource =
                   dzn_image_range_get_subresource_index(image, range, VK_IMAGE_ASPECT_COLOR_BIT, lvl, layer);
-               cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
             }
          }
       }
@@ -1382,15 +1395,19 @@ dzn_cmd_buffer_clear_zs(dzn_cmd_buffer *cmdbuf,
                      dzn_image_range_get_subresource_index(image, range, barrier_aspects[b], lvl, layer);
                }
 
-               cmdbuf->cmdlist->ResourceBarrier(barrier_count, barriers);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist,
+                                                          barrier_count,
+                                                          barriers);
             }
          }
 
          auto desc = dzn_image_get_dsv_desc(image, range, lvl);
          auto handle = dzn_cmd_buffer_get_dsv(cmdbuf, image, &desc);
-         cmdbuf->cmdlist->ClearDepthStencilView(handle, flags,
-                                                zs->depth, zs->stencil,
-                                                0, NULL);
+         ID3D12GraphicsCommandList1_ClearDepthStencilView(cmdbuf->cmdlist,
+                                                          handle, flags,
+                                                          zs->depth,
+                                                          zs->stencil,
+                                                          0, NULL);
 
          if (barrier_count > 0) {
             for (uint32_t b = 0; b < barrier_count; b++)
@@ -1402,7 +1419,9 @@ dzn_cmd_buffer_clear_zs(dzn_cmd_buffer *cmdbuf,
                      dzn_image_range_get_subresource_index(image, range, barrier_aspects[b], lvl, layer);
                }
 
-               cmdbuf->cmdlist->ResourceBarrier(barrier_count, barriers);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist,
+                                                          barrier_count,
+                                                          barriers);
             }
          }
       }
@@ -1446,9 +1465,11 @@ dzn_cmd_buffer_copy_buf2img_region(dzn_cmd_buffer *cmdbuf,
          .back = region->imageExtent.depth,
       };
 
-      cmdlist->CopyTextureRegion(&dst_img_loc, region->imageOffset.x,
-                                 region->imageOffset.y, region->imageOffset.z,
-                                 &src_buf_loc, &src_box);
+      ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist, &dst_img_loc,
+                                                   region->imageOffset.x,
+                                                   region->imageOffset.y,
+                                                   region->imageOffset.z,
+                                                   &src_buf_loc, &src_box);
       return;
    }
 
@@ -1471,11 +1492,13 @@ dzn_cmd_buffer_copy_buf2img_region(dzn_cmd_buffer *cmdbuf,
 
          src_box.left = src_x;
          src_box.right = src_x + region->imageExtent.width;
-         cmdlist->CopyTextureRegion(&dst_img_loc,
-                                    region->imageOffset.x,
-                                    region->imageOffset.y + y,
-                                    region->imageOffset.z + z,
-                                    &src_buf_line_loc, &src_box);
+         ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist,
+                                                      &dst_img_loc,
+                                                      region->imageOffset.x,
+                                                      region->imageOffset.y + y,
+                                                      region->imageOffset.z + z,
+                                                      &src_buf_line_loc,
+                                                      &src_box);
       }
    }
 }
@@ -1517,8 +1540,9 @@ dzn_cmd_buffer_copy_img2buf_region(dzn_cmd_buffer *cmdbuf,
          .back = (UINT)(region->imageOffset.z + region->imageExtent.depth),
       };
 
-      cmdlist->CopyTextureRegion(&dst_buf_loc, 0, 0, 0,
-                                 &src_img_loc, &src_box);
+      ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist, &dst_buf_loc,
+                                                   0, 0, 0, &src_img_loc,
+                                                   &src_box);
       return;
    }
 
@@ -1543,8 +1567,11 @@ dzn_cmd_buffer_copy_img2buf_region(dzn_cmd_buffer *cmdbuf,
          src_box.top = region->imageOffset.y + y;
          src_box.bottom = src_box.top + blkh;
 
-         cmdlist->CopyTextureRegion(&dst_buf_line_loc, dst_x, 0, 0,
-                                    &src_img_loc, &src_box);
+         ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist,
+                                                      &dst_buf_line_loc,
+                                                      dst_x, 0, 0,
+                                                      &src_img_loc,
+                                                      &src_box);
       }
    }
 }
@@ -1616,9 +1643,11 @@ dzn_cmd_buffer_copy_img_chunk(dzn_cmd_buffer *cmdbuf,
    };
 
    if (!tmp_loc->pResource) {
-      cmdlist->CopyTextureRegion(&dst_loc, region->dstOffset.x,
-                                 region->dstOffset.y, dst_z,
-                                 &src_loc, &src_box);
+      ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist, &dst_loc,
+                                                   region->dstOffset.x,
+                                                   region->dstOffset.y,
+                                                   dst_z, &src_loc,
+                                                   &src_box);
       return;
    }
 
@@ -1627,10 +1656,10 @@ dzn_cmd_buffer_copy_img_chunk(dzn_cmd_buffer *cmdbuf,
    tmp_desc->Width = region->extent.width;
    tmp_desc->Height = region->extent.height;
 
-   dev->GetCopyableFootprints(tmp_desc,
-                              0, 1, 0,
-                              &tmp_loc->PlacedFootprint,
-                              NULL, NULL, NULL);
+   ID3D12Device1_GetCopyableFootprints(dev, tmp_desc,
+                                       0, 1, 0,
+                                       &tmp_loc->PlacedFootprint,
+                                       NULL, NULL, NULL);
 
    tmp_loc->PlacedFootprint.Footprint.Depth = depth;
 
@@ -1646,12 +1675,12 @@ dzn_cmd_buffer_copy_img_chunk(dzn_cmd_buffer *cmdbuf,
    };
 
    if (r > 0 || l > 0)
-      cmdlist->ResourceBarrier(1, &barrier);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdlist, 1, &barrier);
 
-   cmdlist->CopyTextureRegion(tmp_loc, 0, 0, 0, &src_loc, &src_box);
+   ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist, tmp_loc, 0, 0, 0, &src_loc, &src_box);
 
    DZN_SWAP(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
-   cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdlist, 1, &barrier);
 
    tmp_desc->Format =
       dzn_image_get_placed_footprint_format(dst->vk.format, aspect);
@@ -1660,10 +1689,10 @@ dzn_cmd_buffer_copy_img_chunk(dzn_cmd_buffer *cmdbuf,
    if (src_blkh != dst_blkh)
       tmp_desc->Height = DIV_ROUND_UP(region->extent.height, src_blkh) * dst_blkh;
 
-   device->dev->GetCopyableFootprints(tmp_desc,
-                                      0, 1, 0,
-                                      &tmp_loc->PlacedFootprint,
-                                      NULL, NULL, NULL);
+   ID3D12Device1_GetCopyableFootprints(device->dev, tmp_desc,
+                                       0, 1, 0,
+                                       &tmp_loc->PlacedFootprint,
+                                       NULL, NULL, NULL);
 
    if (src_blkd != dst_blkd) {
       tmp_loc->PlacedFootprint.Footprint.Depth =
@@ -1681,11 +1710,11 @@ dzn_cmd_buffer_copy_img_chunk(dzn_cmd_buffer *cmdbuf,
       .back = tmp_loc->PlacedFootprint.Footprint.Depth,
    };
 
-   cmdlist->CopyTextureRegion(&dst_loc,
-                              region->dstOffset.x,
-                              region->dstOffset.y,
-                              dst_z,
-                              tmp_loc, &tmp_box);
+   ID3D12GraphicsCommandList1_CopyTextureRegion(cmdlist, &dst_loc,
+                                                region->dstOffset.x,
+                                                region->dstOffset.y,
+                                                dst_z,
+                                                tmp_loc, &tmp_box);
 }
 
 static void
@@ -1746,7 +1775,7 @@ dzn_cmd_buffer_blit_prepare_src_view(dzn_cmd_buffer *cmdbuf,
 
    D3D12_GPU_DESCRIPTOR_HANDLE handle =
       dzn_descriptor_heap_get_gpu_handle(heap, heap_slot);
-   cmdbuf->cmdlist->SetGraphicsRootDescriptorTable(0, handle);
+   ID3D12GraphicsCommandList1_SetGraphicsRootDescriptorTable(cmdbuf->cmdlist, 0, handle);
 }
 
 static void
@@ -1767,11 +1796,11 @@ dzn_cmd_buffer_blit_prepare_dst_view(dzn_cmd_buffer *cmdbuf,
    if (ds) {
       auto desc = dzn_image_get_dsv_desc(img, &range, 0);
       auto handle = dzn_cmd_buffer_get_dsv(cmdbuf, img, &desc);
-      cmdbuf->cmdlist->OMSetRenderTargets(0, NULL, TRUE, &handle);
+      ID3D12GraphicsCommandList1_OMSetRenderTargets(cmdbuf->cmdlist, 0, NULL, TRUE, &handle);
    } else {
       auto desc = dzn_image_get_rtv_desc(img, &range, 0);
       auto handle = dzn_cmd_buffer_get_rtv(cmdbuf, img, &desc);
-      cmdbuf->cmdlist->OMSetRenderTargets(1, &handle, FALSE, NULL);
+      ID3D12GraphicsCommandList1_OMSetRenderTargets(cmdbuf->cmdlist, 1, &handle, FALSE, NULL);
    }
 }
 
@@ -1814,8 +1843,8 @@ dzn_cmd_buffer_blit_set_pipeline(dzn_cmd_buffer *cmdbuf,
       dzn_meta_blits_get_context(device, &ctx_key);
    assert(ctx);
 
-   cmdbuf->cmdlist->SetGraphicsRootSignature(ctx->root_sig);
-   cmdbuf->cmdlist->SetPipelineState(ctx->pipeline_state);
+   ID3D12GraphicsCommandList1_SetGraphicsRootSignature(cmdbuf->cmdlist, ctx->root_sig);
+   ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, ctx->pipeline_state);
 }
 
 static void
@@ -1857,7 +1886,7 @@ dzn_cmd_buffer_blit_set_2d_region(dzn_cmd_buffer *cmdbuf,
       dst_pos[2], dst_pos[3], src_pos[2], src_pos[3],
    };
 
-   cmdbuf->cmdlist->SetGraphicsRoot32BitConstants(1, ARRAY_SIZE(coords), coords, 0);
+   ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(cmdbuf->cmdlist, 1, ARRAY_SIZE(coords), coords, 0);
 
    D3D12_VIEWPORT vp = {
       .TopLeftX = 0,
@@ -1867,7 +1896,7 @@ dzn_cmd_buffer_blit_set_2d_region(dzn_cmd_buffer *cmdbuf,
       .MinDepth = 0,
       .MaxDepth = 1,
    };
-   cmdbuf->cmdlist->RSSetViewports(1, &vp);
+   ID3D12GraphicsCommandList1_RSSetViewports(cmdbuf->cmdlist, 1, &vp);
 
    D3D12_RECT scissor = {
       .left = MIN2(dst_offsets[0].x, dst_offsets[1].x),
@@ -1875,7 +1904,7 @@ dzn_cmd_buffer_blit_set_2d_region(dzn_cmd_buffer *cmdbuf,
       .right = MAX2(dst_offsets[0].x, dst_offsets[1].x),
       .bottom = MAX2(dst_offsets[0].y, dst_offsets[1].y),
    };
-   cmdbuf->cmdlist->RSSetScissorRects(1, &scissor);
+   ID3D12GraphicsCommandList1_RSSetScissorRects(cmdbuf->cmdlist, 1, &scissor);
 }
 
 static void
@@ -1929,7 +1958,7 @@ dzn_cmd_buffer_blit_issue_barriers(dzn_cmd_buffer *cmdbuf,
          dzn_image_layers_get_subresource_index(src, src_subres, aspect, layer);
       barriers[1].Transition.Subresource =
          dzn_image_layers_get_subresource_index(dst, dst_subres, aspect, layer);
-      cmdbuf->cmdlist->ResourceBarrier(ARRAY_SIZE(barriers), barriers);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, ARRAY_SIZE(barriers), barriers);
    }
 }
 
@@ -1996,8 +2025,8 @@ dzn_cmd_buffer_blit_region(dzn_cmd_buffer *cmdbuf,
 
       for (uint32_t slice = 0; slice < slice_count; slice++) {
          dzn_cmd_buffer_blit_prepare_dst_view(cmdbuf, dst, aspect, dst_level, dst_z_coord);
-         cmdbuf->cmdlist->SetGraphicsRoot32BitConstants(1, 1, &src_z_coord, 16);
-         cmdbuf->cmdlist->DrawInstanced(4, 1, 0, 0);
+         ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(cmdbuf->cmdlist, 1, 1, &src_z_coord, 16);
+         ID3D12GraphicsCommandList1_DrawInstanced(cmdbuf->cmdlist, 4, 1, 0, 0);
          src_z_coord += src_slice_step;
          dst_z_coord += dst_slice_step;
       }
@@ -2066,8 +2095,8 @@ dzn_cmd_buffer_resolve_region(dzn_cmd_buffer *cmdbuf,
          dzn_cmd_buffer_blit_prepare_dst_view(cmdbuf,
                                               dst, aspect, region->dstSubresource.mipLevel,
                                               region->dstSubresource.baseArrayLayer + layer);
-         cmdbuf->cmdlist->SetGraphicsRoot32BitConstants(1, 1, &src_z_coord, 16);
-         cmdbuf->cmdlist->DrawInstanced(4, 1, 0, 0);
+         ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(cmdbuf->cmdlist, 1, 1, &src_z_coord, 16);
+         ID3D12GraphicsCommandList1_DrawInstanced(cmdbuf->cmdlist, 4, 1, 0, 0);
       }
 
       dzn_cmd_buffer_blit_issue_barriers(cmdbuf,
@@ -2142,7 +2171,7 @@ dzn_cmd_buffer_attachment_ref_transition(dzn_cmd_buffer *cmdbuf,
             };
 
             if (barrier.Transition.StateBefore != barrier.Transition.StateAfter)
-               cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
          }
       }
    }
@@ -2182,7 +2211,7 @@ dzn_cmd_buffer_attachment_transition(dzn_cmd_buffer *cmdbuf,
             };
 
             if (barrier.Transition.StateBefore != barrier.Transition.StateAfter)
-               cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+               ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
          }
       }
    }
@@ -2233,9 +2262,9 @@ dzn_cmd_buffer_resolve_attachment(dzn_cmd_buffer *cmdbuf, uint32_t i)
    }
 
    if (barrier_count)
-     cmdbuf->cmdlist->ResourceBarrier(barrier_count, barriers);
+     ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, barrier_count, barriers);
 
-   cmdbuf->cmdlist->ResolveSubresource(dst_img->res, 0,
+   ID3D12GraphicsCommandList1_ResolveSubresource(cmdbuf->cmdlist, dst_img->res, 0,
                                        src_img->res, 0,
                                        dst->srv_desc.Format);
 
@@ -2243,7 +2272,7 @@ dzn_cmd_buffer_resolve_attachment(dzn_cmd_buffer *cmdbuf, uint32_t i)
       DZN_SWAP(barriers[b].Transition.StateBefore, barriers[b].Transition.StateAfter);
 
    if (barrier_count)
-      cmdbuf->cmdlist->ResourceBarrier(barrier_count, barriers);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, barrier_count, barriers);
 }
 
 static void
@@ -2272,7 +2301,7 @@ dzn_cmd_buffer_begin_subpass(dzn_cmd_buffer *cmdbuf)
       zs_handle = dzn_cmd_buffer_get_dsv(cmdbuf, img, &iview->dsv_desc);
    }
 
-   cmdbuf->cmdlist->OMSetRenderTargets(subpass->color_count,
+   ID3D12GraphicsCommandList1_OMSetRenderTargets(cmdbuf->cmdlist, subpass->color_count,
                                        subpass->color_count ? rt_handles : NULL,
                                        FALSE, zs_handle.ptr ? &zs_handle : NULL);
 
@@ -2306,15 +2335,15 @@ dzn_cmd_buffer_update_pipeline(dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
       if (bindpoint == VK_PIPELINE_BIND_POINT_GRAPHICS) {
          const dzn_graphics_pipeline *gfx =
             reinterpret_cast<const dzn_graphics_pipeline *>(pipeline);
-         cmdbuf->cmdlist->SetGraphicsRootSignature(pipeline->root.sig);
-         cmdbuf->cmdlist->IASetPrimitiveTopology(gfx->ia.topology);
+         ID3D12GraphicsCommandList1_SetGraphicsRootSignature(cmdbuf->cmdlist, pipeline->root.sig);
+         ID3D12GraphicsCommandList1_IASetPrimitiveTopology(cmdbuf->cmdlist, gfx->ia.topology);
       } else {
-         cmdbuf->cmdlist->SetComputeRootSignature(pipeline->root.sig);
+         ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, pipeline->root.sig);
       }
    }
 
    if (cmdbuf->state.pipeline != pipeline) {
-      cmdbuf->cmdlist->SetPipelineState(pipeline->state);
+      ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, pipeline->state);
       cmdbuf->state.pipeline = pipeline;
    }
 }
@@ -2402,7 +2431,7 @@ set_heaps:
          desc_heaps[num_desc_heaps++] = new_heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV]->heap;
       if (new_heaps[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER])
          desc_heaps[num_desc_heaps++] = new_heaps[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER]->heap;
-      cmdbuf->cmdlist->SetDescriptorHeaps(num_desc_heaps, desc_heaps);
+      ID3D12GraphicsCommandList1_SetDescriptorHeaps(cmdbuf->cmdlist, num_desc_heaps, desc_heaps);
 
       for (unsigned h = 0; h < ARRAY_SIZE(cmdbuf->state.heaps); h++)
          cmdbuf->state.heaps[h] = new_heaps[h];
@@ -2418,9 +2447,9 @@ set_heaps:
          dzn_descriptor_heap_get_gpu_handle(new_heaps[type], new_heap_offsets[type]);
 
       if (bindpoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
-         cmdbuf->cmdlist->SetGraphicsRootDescriptorTable(r, handle);
+         ID3D12GraphicsCommandList1_SetGraphicsRootDescriptorTable(cmdbuf->cmdlist, r, handle);
       else
-         cmdbuf->cmdlist->SetComputeRootDescriptorTable(r, handle);
+         ID3D12GraphicsCommandList1_SetComputeRootDescriptorTable(cmdbuf->cmdlist, r, handle);
    }
 }
 
@@ -2434,11 +2463,11 @@ dzn_cmd_buffer_update_sysvals(dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
    uint32_t sysval_cbv_param_idx = pipeline->root.sysval_cbv_param_idx;
 
    if (bindpoint == VK_PIPELINE_BIND_POINT_GRAPHICS) {
-      cmdbuf->cmdlist->SetGraphicsRoot32BitConstants(sysval_cbv_param_idx,
+      ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(cmdbuf->cmdlist, sysval_cbv_param_idx,
                                                      sizeof(cmdbuf->state.sysvals.gfx) / 4,
                                                      &cmdbuf->state.sysvals.gfx, 0);
    } else {
-      cmdbuf->cmdlist->SetComputeRoot32BitConstants(sysval_cbv_param_idx,
+      ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, sysval_cbv_param_idx,
                                                     sizeof(cmdbuf->state.sysvals.compute) / 4,
                                                     &cmdbuf->state.sysvals.compute, 0);
    }
@@ -2454,7 +2483,7 @@ dzn_cmd_buffer_update_viewports(dzn_cmd_buffer *cmdbuf)
        !pipeline->vp.count)
       return;
 
-   cmdbuf->cmdlist->RSSetViewports(pipeline->vp.count, cmdbuf->state.viewports);
+   ID3D12GraphicsCommandList1_RSSetViewports(cmdbuf->cmdlist, pipeline->vp.count, cmdbuf->state.viewports);
 }
 
 static void
@@ -2468,7 +2497,7 @@ dzn_cmd_buffer_update_scissors(dzn_cmd_buffer *cmdbuf)
 
    if (!pipeline->scissor.count) {
       /* Apply a scissor delimiting the render area. */
-      cmdbuf->cmdlist->RSSetScissorRects(1, &cmdbuf->state.render_area);
+      ID3D12GraphicsCommandList1_RSSetScissorRects(cmdbuf->cmdlist, 1, &cmdbuf->state.render_area);
       return;
    }
 
@@ -2483,7 +2512,7 @@ dzn_cmd_buffer_update_scissors(dzn_cmd_buffer *cmdbuf)
       scissors[i].bottom = MIN2(scissors[i].bottom, cmdbuf->state.render_area.bottom);
    }
 
-   cmdbuf->cmdlist->RSSetScissorRects(pipeline->scissor.count, scissors);
+   ID3D12GraphicsCommandList1_RSSetScissorRects(cmdbuf->cmdlist, pipeline->scissor.count, scissors);
 }
 
 static void
@@ -2494,7 +2523,7 @@ dzn_cmd_buffer_update_vbviews(dzn_cmd_buffer *cmdbuf)
    unsigned start, end;
 
    BITSET_FOREACH_RANGE(start, end, cmdbuf->state.vb.dirty, MAX_VBS)
-      cmdbuf->cmdlist->IASetVertexBuffers(start, end - start, cmdbuf->state.vb.views);
+      ID3D12GraphicsCommandList1_IASetVertexBuffers(cmdbuf->cmdlist, start, end - start, cmdbuf->state.vb.views);
 
    BITSET_CLEAR_RANGE(cmdbuf->state.vb.dirty, 0, MAX_VBS);
 }
@@ -2505,7 +2534,7 @@ dzn_cmd_buffer_update_ibview(dzn_cmd_buffer *cmdbuf)
    if (!(cmdbuf->state.dirty & DZN_CMD_DIRTY_IB))
       return;
 
-   cmdbuf->cmdlist->IASetIndexBuffer(&cmdbuf->state.ib.view);
+   ID3D12GraphicsCommandList1_IASetIndexBuffer(cmdbuf->cmdlist, &cmdbuf->state.ib.view);
 }
 
 static void
@@ -2526,9 +2555,9 @@ dzn_cmd_buffer_update_push_constants(dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
    uint32_t *vals = state->values + offset;
 
    if (bindpoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
-      cmdbuf->cmdlist->SetGraphicsRoot32BitConstants(slot, count, vals, offset);
+      ID3D12GraphicsCommandList1_SetGraphicsRoot32BitConstants(cmdbuf->cmdlist, slot, count, vals, offset);
    else
-      cmdbuf->cmdlist->SetComputeRoot32BitConstants(slot, count, vals, offset);
+      ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, slot, count, vals, offset);
 
    state->offset = 0;
    state->end = 0;
@@ -2544,7 +2573,7 @@ dzn_cmd_buffer_update_zsa(dzn_cmd_buffer *cmdbuf)
          gfx->zsa.stencil_test.front.uses_ref ?
          cmdbuf->state.zsa.stencil_test.front.ref :
          cmdbuf->state.zsa.stencil_test.back.ref;
-      cmdbuf->cmdlist->OMSetStencilRef(ref);
+      ID3D12GraphicsCommandList1_OMSetStencilRef(cmdbuf->cmdlist, ref);
    }
 }
 
@@ -2552,7 +2581,8 @@ static void
 dzn_cmd_buffer_update_blend_constants(dzn_cmd_buffer *cmdbuf)
 {
    if (cmdbuf->state.dirty & DZN_CMD_DIRTY_BLEND_CONSTANTS)
-      cmdbuf->cmdlist->OMSetBlendFactor(cmdbuf->state.blend.constants);
+      ID3D12GraphicsCommandList1_OMSetBlendFactor(cmdbuf->cmdlist,
+                                                  cmdbuf->state.blend.constants);
 }
 
 static VkResult
@@ -2576,7 +2606,7 @@ dzn_cmd_buffer_triangle_fan_create_index(dzn_cmd_buffer *cmdbuf, uint32_t *verte
       return result;
 
    void *cpu_ptr;
-   index_buf->Map(0, NULL, &cpu_ptr);
+   ID3D12Resource_Map(index_buf, 0, NULL, &cpu_ptr);
 
    /* TODO: VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT */
    if (index_size == 2) {
@@ -2598,7 +2628,7 @@ dzn_cmd_buffer_triangle_fan_create_index(dzn_cmd_buffer *cmdbuf, uint32_t *verte
    }
 
    cmdbuf->state.ib.view.SizeInBytes = *vertex_count * index_size;
-   cmdbuf->state.ib.view.BufferLocation = index_buf->GetGPUVirtualAddress();
+   cmdbuf->state.ib.view.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(index_buf);
    cmdbuf->state.dirty |= DZN_CMD_DIRTY_IB;
    return VK_SUCCESS;
 }
@@ -2641,13 +2671,13 @@ dzn_cmd_buffer_triangle_fan_rewrite_index(dzn_cmd_buffer *cmdbuf,
       .first_index = *first_index,
    };
 
-   cmdbuf->cmdlist->SetComputeRootSignature(rewrite_index->root_sig);
-   cmdbuf->cmdlist->SetPipelineState(rewrite_index->pipeline_state);
-   cmdbuf->cmdlist->SetComputeRootUnorderedAccessView(0, new_index_buf->GetGPUVirtualAddress());
-   cmdbuf->cmdlist->SetComputeRoot32BitConstants(1, sizeof(params) / 4,
+   ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, rewrite_index->root_sig);
+   ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, rewrite_index->pipeline_state);
+   ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(cmdbuf->cmdlist, 0, ID3D12Resource_GetGPUVirtualAddress(new_index_buf));
+   ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, 1, sizeof(params) / 4,
                                                  &params, 0);
-   cmdbuf->cmdlist->SetComputeRootShaderResourceView(2, old_index_buf_gpu);
-   cmdbuf->cmdlist->Dispatch(triangle_count, 1, 1);
+   ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(cmdbuf->cmdlist, 2, old_index_buf_gpu);
+   ID3D12GraphicsCommandList1_Dispatch(cmdbuf->cmdlist, triangle_count, 1, 1);
 
    D3D12_RESOURCE_BARRIER post_barriers[] = {
       {
@@ -2665,7 +2695,7 @@ dzn_cmd_buffer_triangle_fan_rewrite_index(dzn_cmd_buffer *cmdbuf,
       },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(ARRAY_SIZE(post_barriers), post_barriers);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, ARRAY_SIZE(post_barriers), post_barriers);
 
    /* We don't mess up with the driver state when executing our internal
     * compute shader, but we still change the D3D12 state, so let's mark
@@ -2678,7 +2708,7 @@ dzn_cmd_buffer_triangle_fan_rewrite_index(dzn_cmd_buffer *cmdbuf,
    }
 
    cmdbuf->state.ib.view.SizeInBytes = *index_count * 4;
-   cmdbuf->state.ib.view.BufferLocation = new_index_buf->GetGPUVirtualAddress();
+   cmdbuf->state.ib.view.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(new_index_buf);
    cmdbuf->state.ib.view.Format = DXGI_FORMAT_R32_UINT;
    cmdbuf->state.dirty |= DZN_CMD_DIRTY_IB;
    *first_index = 0;
@@ -2774,7 +2804,7 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
       return;
 
    D3D12_GPU_VIRTUAL_ADDRESS draw_buf_gpu =
-      draw_buf->res->GetGPUVirtualAddress() + draw_buf_offset;
+      ID3D12Resource_GetGPUVirtualAddress(draw_buf->res) + draw_buf_offset;
    ID3D12Resource *triangle_fan_index_buf = NULL;
    ID3D12Resource *triangle_fan_exec_buf = NULL;
 
@@ -2803,7 +2833,7 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
       .triangle_fan_index_buf_stride = triangle_fan_index_buf_stride,
       .triangle_fan_index_buf_start =
          triangle_fan_index_buf ?
-         triangle_fan_index_buf->GetGPUVirtualAddress() : 0,
+         ID3D12Resource_GetGPUVirtualAddress(triangle_fan_index_buf) : 0,
    };
    uint32_t params_size =
       triangle_fan_index_buf_stride > 0 ?
@@ -2826,15 +2856,15 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
    const dzn_pipeline *compute_pipeline =
       cmdbuf->state.bindpoint[VK_PIPELINE_BIND_POINT_COMPUTE].pipeline;
 
-   cmdbuf->cmdlist->SetComputeRootSignature(indirect_draw->root_sig);
-   cmdbuf->cmdlist->SetPipelineState(indirect_draw->pipeline_state);
-   cmdbuf->cmdlist->SetComputeRoot32BitConstants(0, params_size / 4, (const void *)&params, 0);
-   cmdbuf->cmdlist->SetComputeRootShaderResourceView(1, draw_buf_gpu);
-   cmdbuf->cmdlist->SetComputeRootUnorderedAccessView(2, exec_buf->GetGPUVirtualAddress());
+   ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, indirect_draw->root_sig);
+   ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, indirect_draw->pipeline_state);
+   ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, 0, params_size / 4, (const void *)&params, 0);
+   ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(cmdbuf->cmdlist, 1, draw_buf_gpu);
+   ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(cmdbuf->cmdlist, 2, ID3D12Resource_GetGPUVirtualAddress(exec_buf));
    if (triangle_fan_exec_buf)
-      cmdbuf->cmdlist->SetComputeRootUnorderedAccessView(3, triangle_fan_exec_buf->GetGPUVirtualAddress());
+      ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(cmdbuf->cmdlist, 3, ID3D12Resource_GetGPUVirtualAddress(triangle_fan_exec_buf));
 
-   cmdbuf->cmdlist->Dispatch(draw_count, 1, 1);
+   ID3D12GraphicsCommandList1_Dispatch(cmdbuf->cmdlist, draw_count, 1, 1);
 
    D3D12_RESOURCE_BARRIER post_barriers[] = {
       {
@@ -2867,7 +2897,7 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
 
    uint32_t post_barrier_count = triangle_fan_exec_buf ? 2 : 1;
 
-   cmdbuf->cmdlist->ResourceBarrier(post_barrier_count, post_barriers);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, post_barrier_count, post_barriers);
 
    D3D12_INDEX_BUFFER_VIEW ib_view = {};
 
@@ -2885,16 +2915,16 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
       assert(rewrite_index->pipeline_state);
       assert(rewrite_index->cmd_sig);
 
-      cmdbuf->cmdlist->SetComputeRootSignature(rewrite_index->root_sig);
-      cmdbuf->cmdlist->SetPipelineState(rewrite_index->pipeline_state);
-      cmdbuf->cmdlist->SetComputeRootUnorderedAccessView(0, triangle_fan_index_buf->GetGPUVirtualAddress());
-      cmdbuf->cmdlist->SetComputeRoot32BitConstants(1, sizeof(rewrite_index_params) / 4,
-                                                    (const void *)&rewrite_index_params, 0);
+      ID3D12GraphicsCommandList1_SetComputeRootSignature(cmdbuf->cmdlist, rewrite_index->root_sig);
+      ID3D12GraphicsCommandList1_SetPipelineState(cmdbuf->cmdlist, rewrite_index->pipeline_state);
+      ID3D12GraphicsCommandList1_SetComputeRootUnorderedAccessView(cmdbuf->cmdlist, 0, ID3D12Resource_GetGPUVirtualAddress(triangle_fan_index_buf));
+      ID3D12GraphicsCommandList1_SetComputeRoot32BitConstants(cmdbuf->cmdlist, 1, sizeof(rewrite_index_params) / 4,
+                                                              (const void *)&rewrite_index_params, 0);
 
       if (indexed)
-         cmdbuf->cmdlist->SetComputeRootShaderResourceView(2, cmdbuf->state.ib.view.BufferLocation);
+         ID3D12GraphicsCommandList1_SetComputeRootShaderResourceView(cmdbuf->cmdlist, 2, cmdbuf->state.ib.view.BufferLocation);
 
-      cmdbuf->cmdlist->ExecuteIndirect(rewrite_index->cmd_sig,
+      ID3D12GraphicsCommandList1_ExecuteIndirect(cmdbuf->cmdlist, rewrite_index->cmd_sig,
                                        draw_count, triangle_fan_exec_buf,
                                        0, NULL, 0);
 
@@ -2911,12 +2941,12 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
          },
       };
 
-      cmdbuf->cmdlist->ResourceBarrier(ARRAY_SIZE(index_buf_barriers), index_buf_barriers);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, ARRAY_SIZE(index_buf_barriers), index_buf_barriers);
 
       /* After our triangle-fan lowering the draw is indexed */
       indexed = true;
       ib_view = cmdbuf->state.ib.view;
-      cmdbuf->state.ib.view.BufferLocation = triangle_fan_index_buf->GetGPUVirtualAddress();
+      cmdbuf->state.ib.view.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(triangle_fan_index_buf);
       cmdbuf->state.ib.view.SizeInBytes = triangle_fan_index_buf_stride;
       cmdbuf->state.ib.view.Format = DXGI_FORMAT_R32_UINT;
       cmdbuf->state.dirty |= DZN_CMD_DIRTY_IB;
@@ -2960,7 +2990,7 @@ dzn_cmd_buffer_indirect_draw(dzn_cmd_buffer *cmdbuf,
       return;
    }
 
-   cmdbuf->cmdlist->ExecuteIndirect(cmdsig,
+   ID3D12GraphicsCommandList1_ExecuteIndirect(cmdbuf->cmdlist, cmdsig,
                                     draw_count, exec_buf, 0, NULL, 0);
 }
 
@@ -2987,7 +3017,7 @@ dzn_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
    for (int i = 0; i < info->regionCount; i++) {
       auto &region = info->pRegions[i];
 
-      cmdbuf->cmdlist->CopyBufferRegion(dst_buffer->res, region.dstOffset,
+      ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, dst_buffer->res, region.dstOffset,
                                         src_buffer->res, region.srcOffset,
                                         region.size);
    }
@@ -3137,10 +3167,10 @@ dzn_CmdCopyImage2(VkCommandBuffer commandBuffer,
          tmp_desc.Width = region->extent.width;
          tmp_desc.Height = region->extent.height;
 
-         dev->GetCopyableFootprints(&src->desc,
-                                    0, 1, 0,
-                                    NULL, NULL, NULL,
-                                    &region_size);
+         ID3D12Device1_GetCopyableFootprints(dev, &src->desc,
+                                             0, 1, 0,
+                                             NULL, NULL, NULL,
+                                             &region_size);
          max_size = MAX2(max_size, region_size * region->extent.depth);
       }
 
@@ -3193,10 +3223,10 @@ dzn_CmdBlitImage2(VkCommandBuffer commandBuffer,
    if (heap != cmdbuf->state.heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV]) {
       ID3D12DescriptorHeap * const heaps[] = { heap->heap };
       cmdbuf->state.heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV] = heap;
-      cmdbuf->cmdlist->SetDescriptorHeaps(ARRAY_SIZE(heaps), heaps);
+      ID3D12GraphicsCommandList1_SetDescriptorHeaps(cmdbuf->cmdlist, ARRAY_SIZE(heaps), heaps);
    }
 
-   cmdbuf->cmdlist->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+   ID3D12GraphicsCommandList1_IASetPrimitiveTopology(cmdbuf->cmdlist, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
    uint32_t heap_offset = 0;
    for (uint32_t r = 0; r < info->regionCount; r++)
@@ -3237,10 +3267,10 @@ dzn_CmdResolveImage2(VkCommandBuffer commandBuffer,
    if (heap != cmdbuf->state.heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV]) {
       ID3D12DescriptorHeap * const heaps[] = { heap->heap };
       cmdbuf->state.heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV] = heap;
-      cmdbuf->cmdlist->SetDescriptorHeaps(ARRAY_SIZE(heaps), heaps);
+      ID3D12GraphicsCommandList1_SetDescriptorHeaps(cmdbuf->cmdlist, ARRAY_SIZE(heaps), heaps);
    }
 
-   cmdbuf->cmdlist->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+   ID3D12GraphicsCommandList1_IASetPrimitiveTopology(cmdbuf->cmdlist, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
 
    uint32_t heap_offset = 0;
    for (uint32_t r = 0; r < info->regionCount; r++)
@@ -3297,7 +3327,7 @@ dzn_CmdDispatch(VkCommandBuffer commandBuffer,
       DZN_CMD_BINDPOINT_DIRTY_SYSVALS;
 
    dzn_cmd_buffer_prepare_dispatch(cmdbuf);
-   cmdbuf->cmdlist->Dispatch(groupCountX, groupCountY, groupCountZ);
+   ID3D12GraphicsCommandList1_Dispatch(cmdbuf->cmdlist, groupCountX, groupCountY, groupCountZ);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -3325,13 +3355,13 @@ dzn_CmdFillBuffer(VkCommandBuffer commandBuffer,
       return;
 
    uint32_t *cpu_ptr;
-   src_res->Map(0, NULL, (void **)&cpu_ptr);
+   ID3D12Resource_Map(src_res, 0, NULL, (void **)&cpu_ptr);
    for (uint32_t i = 0; i < size / 4; i++)
       cpu_ptr[i] = data;
 
-   src_res->Unmap(0, NULL);
+   ID3D12Resource_Unmap(src_res, 0, NULL);
 
-   cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset, src_res, 0, size);
+   ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset, src_res, 0, size);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -3349,7 +3379,6 @@ dzn_CmdUpdateBuffer(VkCommandBuffer commandBuffer,
 
    /*
     * The spec says:
-    *  "size is the number of bytes to fill, and must be either a multiple of
     *   4, or VK_WHOLE_SIZE to fill the range from offset to the end of the
     *   buffer. If VK_WHOLE_SIZE is used and the remaining size of the buffer
     *   is not a multiple of 4, then the nearest smaller multiple is used."
@@ -3366,11 +3395,11 @@ dzn_CmdUpdateBuffer(VkCommandBuffer commandBuffer,
       return;
 
    void *cpu_ptr;
-   src_res->Map(0, NULL, &cpu_ptr);
+   ID3D12Resource_Map(src_res, 0, NULL, &cpu_ptr);
    memcpy(cpu_ptr, data, size),
-   src_res->Unmap(0, NULL);
+   ID3D12Resource_Unmap(src_res, 0, NULL);
 
-   cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset, src_res, 0, size);
+   ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset, src_res, 0, size);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -3650,7 +3679,7 @@ dzn_CmdDraw(VkCommandBuffer commandBuffer,
 
       cmdbuf->state.sysvals.gfx.is_indexed_draw = true;
       dzn_cmd_buffer_prepare_draw(cmdbuf, true);
-      cmdbuf->cmdlist->DrawIndexedInstanced(vertexCount, instanceCount, 0,
+      ID3D12GraphicsCommandList1_DrawIndexedInstanced(cmdbuf->cmdlist, vertexCount, instanceCount, 0,
                                             firstVertex, firstInstance);
 
       /* Restore the IB view if we modified it when lowering triangle fans. */
@@ -3661,7 +3690,7 @@ dzn_CmdDraw(VkCommandBuffer commandBuffer,
    } else {
       cmdbuf->state.sysvals.gfx.is_indexed_draw = false;
       dzn_cmd_buffer_prepare_draw(cmdbuf, false);
-      cmdbuf->cmdlist->DrawInstanced(vertexCount, instanceCount,
+      ID3D12GraphicsCommandList1_DrawInstanced(cmdbuf->cmdlist, vertexCount, instanceCount,
                                      firstVertex, firstInstance);
    }
 }
@@ -3695,7 +3724,7 @@ dzn_CmdDrawIndexed(VkCommandBuffer commandBuffer,
    }
 
    dzn_cmd_buffer_prepare_draw(cmdbuf, true);
-   cmdbuf->cmdlist->DrawIndexedInstanced(indexCount, instanceCount, firstIndex,
+   ID3D12GraphicsCommandList1_DrawIndexedInstanced(cmdbuf->cmdlist, indexCount, instanceCount, firstIndex,
                                          vertexOffset, firstInstance);
 
    /* Restore the IB view if we modified it when lowering triangle fans. */
@@ -3748,7 +3777,7 @@ dzn_CmdBindVertexBuffers(VkCommandBuffer commandBuffer,
    for (uint32_t i = 0; i < bindingCount; i++) {
       VK_FROM_HANDLE(dzn_buffer, buf, pBuffers[i]);
 
-      vbviews[firstBinding + i].BufferLocation = buf->res->GetGPUVirtualAddress() + pOffsets[i];
+      vbviews[firstBinding + i].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(buf->res) + pOffsets[i];
       vbviews[firstBinding + i].SizeInBytes = buf->size - pOffsets[i];
    }
 
@@ -3765,7 +3794,7 @@ dzn_CmdBindIndexBuffer(VkCommandBuffer commandBuffer,
    VK_FROM_HANDLE(dzn_cmd_buffer, cmdbuf, commandBuffer);
    VK_FROM_HANDLE(dzn_buffer, buf, buffer);
 
-   cmdbuf->state.ib.view.BufferLocation = buf->res->GetGPUVirtualAddress() + offset;
+   cmdbuf->state.ib.view.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(buf->res) + offset;
    cmdbuf->state.ib.view.SizeInBytes = buf->size - offset;
    switch (indexType) {
    case VK_INDEX_TYPE_UINT16:
@@ -3878,7 +3907,7 @@ dzn_CmdWaitEvents(VkCommandBuffer commandBuffer,
          .UAV = { .pResource = NULL },
       };
 
-      cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+      ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
    }
 }
 
@@ -3899,7 +3928,7 @@ dzn_CmdBeginQuery(VkCommandBuffer commandBuffer,
 
    qpool->queries[query].type = dzn_query_pool_get_query_type(qpool, flags);
    dzn_cmd_buffer_dynbitset_clear(cmdbuf, &state->collect, query);
-   cmdbuf->cmdlist->BeginQuery(qpool->heap, qpool->queries[query].type, query);
+   ID3D12GraphicsCommandList1_BeginQuery(cmdbuf->cmdlist, qpool->heap, qpool->queries[query].type, query);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -3916,7 +3945,7 @@ dzn_CmdEndQuery(VkCommandBuffer commandBuffer,
       return;
 
    dzn_cmd_buffer_dynbitset_set(cmdbuf, &state->collect, query);
-   cmdbuf->cmdlist->EndQuery(qpool->heap, qpool->queries[query].type, query);
+   ID3D12GraphicsCommandList1_EndQuery(cmdbuf->cmdlist, qpool->heap, qpool->queries[query].type, query);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -3940,11 +3969,11 @@ dzn_CmdWriteTimestamp2(VkCommandBuffer commandBuffer,
       .UAV = { .pResource = NULL },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 
    qpool->queries[query].type = D3D12_QUERY_TYPE_TIMESTAMP;
    dzn_cmd_buffer_dynbitset_set(cmdbuf, &state->collect, query);
-   cmdbuf->cmdlist->EndQuery(qpool->heap, qpool->queries[query].type, query);
+   ID3D12GraphicsCommandList1_EndQuery(cmdbuf->cmdlist, qpool->heap, qpool->queries[query].type, query);
 }
 
 
@@ -3969,7 +3998,7 @@ dzn_CmdResetQueryPool(VkCommandBuffer commandBuffer,
    for (uint32_t q = 0; q < queryCount; q += q_step) {
       uint32_t q_count = MIN2(queryCount - q, q_step);
 
-      cmdbuf->cmdlist->CopyBufferRegion(qpool->collect_buffer,
+      ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, qpool->collect_buffer,
                                         dzn_query_pool_get_availability_offset(qpool, firstQuery + q),
                                         device->queries.refs,
                                         DZN_QUERY_REFS_ALL_ZEROS_OFFSET,
@@ -3979,7 +4008,7 @@ dzn_CmdResetQueryPool(VkCommandBuffer commandBuffer,
    q_step = DZN_QUERY_REFS_SECTION_SIZE / qpool->query_size;
 
    for (uint32_t q = 0; q < queryCount; q += q_step) {
-      cmdbuf->cmdlist->CopyBufferRegion(qpool->collect_buffer,
+      ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, qpool->collect_buffer,
                                         dzn_query_pool_get_result_offset(qpool, firstQuery + q),
                                         device->queries.refs,
                                         DZN_QUERY_REFS_ALL_ZEROS_OFFSET,
@@ -4052,10 +4081,10 @@ dzn_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
       },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 
    if (raw_copy) {
-      cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset,
+      ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset,
                                         qpool->collect_buffer,
                                         dzn_query_pool_get_result_offset(qpool, firstQuery),
                                         dzn_query_pool_get_result_size(qpool, queryCount));
@@ -4071,21 +4100,21 @@ dzn_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
                if (!(BITFIELD_BIT(c) & qpool->pipeline_statistics))
                   continue;
 
-               cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset + dst_counter_offset,
+               ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset + dst_counter_offset,
                                                  qpool->collect_buffer,
                                                  res_offset + (c * sizeof(uint64_t)),
                                                  step);
                dst_counter_offset += step;
             }
          } else {
-            cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset,
+            ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset,
                                               qpool->collect_buffer,
                                               res_offset, step);
             dst_counter_offset += step;
          }
 
          if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
-            cmdbuf->cmdlist->CopyBufferRegion(buf->res, dstOffset + dst_counter_offset,
+            ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, buf->res, dstOffset + dst_counter_offset,
                                               qpool->collect_buffer,
                                               dzn_query_pool_get_availability_offset(qpool, firstQuery + q),
                                               step);
@@ -4096,7 +4125,7 @@ dzn_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
    }
 
    DZN_SWAP(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
-   cmdbuf->cmdlist->ResourceBarrier(1, &barrier);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, 1, &barrier);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -4135,11 +4164,11 @@ dzn_CmdDispatchIndirect(VkCommandBuffer commandBuffer,
    if (result != VK_SUCCESS)
       return;
 
-   cmdbuf->cmdlist->CopyBufferRegion(exec_buf, 0,
+   ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, exec_buf, 0,
                                      buf->res,
                                      offset,
                                      sizeof(D3D12_DISPATCH_ARGUMENTS));
-   cmdbuf->cmdlist->CopyBufferRegion(exec_buf, sizeof(D3D12_DISPATCH_ARGUMENTS),
+   ID3D12GraphicsCommandList1_CopyBufferRegion(cmdbuf->cmdlist, exec_buf, sizeof(D3D12_DISPATCH_ARGUMENTS),
                                      buf->res,
                                      offset,
                                      sizeof(D3D12_DISPATCH_ARGUMENTS));
@@ -4159,9 +4188,9 @@ dzn_CmdDispatchIndirect(VkCommandBuffer commandBuffer,
       },
    };
 
-   cmdbuf->cmdlist->ResourceBarrier(ARRAY_SIZE(barriers), barriers);
+   ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, ARRAY_SIZE(barriers), barriers);
 
-   cmdbuf->cmdlist->ExecuteIndirect(cmdsig, 1, exec_buf, 0, NULL, 0);
+   ID3D12GraphicsCommandList1_ExecuteIndirect(cmdbuf->cmdlist, cmdsig, 1, exec_buf, 0, NULL, 0);
 }
 
 VKAPI_ATTR void VKAPI_CALL
@@ -4198,7 +4227,7 @@ dzn_CmdSetDepthBounds(VkCommandBuffer commandBuffer,
 {
    VK_FROM_HANDLE(dzn_cmd_buffer, cmdbuf, commandBuffer);
 
-   cmdbuf->cmdlist->OMSetDepthBounds(minDepthBounds, maxDepthBounds);
+   ID3D12GraphicsCommandList1_OMSetDepthBounds(cmdbuf->cmdlist, minDepthBounds, maxDepthBounds);
 }
 
 VKAPI_ATTR void VKAPI_CALL
diff --git a/src/microsoft/vulkan/dzn_descriptor_set.cpp b/src/microsoft/vulkan/dzn_descriptor_set.cpp
index 7cfba972930..9755cdad4eb 100644
--- a/src/microsoft/vulkan/dzn_descriptor_set.cpp
+++ b/src/microsoft/vulkan/dzn_descriptor_set.cpp
@@ -467,7 +467,7 @@ dzn_pipeline_layout_destroy(dzn_pipeline_layout *layout)
    dzn_device *device = container_of(layout->base.device, dzn_device, vk);
 
    if (layout->root.sig)
-      layout->root.sig->Release();
+      ID3D12RootSignature_Release(layout->root.sig);
 
    vk_free(&device->vk.alloc, layout);
 }
@@ -760,10 +760,10 @@ static void
 dzn_descriptor_heap_finish(dzn_descriptor_heap *heap)
 {
    if (heap->heap)
-      heap->heap->Release();
+      ID3D12DescriptorHeap_Release(heap->heap);
 
    if (heap->dev)
-      heap->dev->Release();
+      ID3D12Device_Release(heap->dev);
 }
 
 static VkResult
@@ -776,8 +776,8 @@ dzn_descriptor_heap_init(dzn_descriptor_heap *heap,
    heap->desc_count = desc_count;
    heap->type = type;
    heap->dev = device->dev;
-   heap->dev->AddRef();
-   heap->desc_sz = device->dev->GetDescriptorHandleIncrementSize(type);
+   ID3D12Device1_AddRef(heap->dev);
+   heap->desc_sz = ID3D12Device1_GetDescriptorHandleIncrementSize(device->dev, type);
 
    D3D12_DESCRIPTOR_HEAP_DESC desc = {
       .Type = type,
@@ -787,16 +787,22 @@ dzn_descriptor_heap_init(dzn_descriptor_heap *heap,
                D3D12_DESCRIPTOR_HEAP_FLAG_NONE,
    };
 
-   if (FAILED(device->dev->CreateDescriptorHeap(&desc,
-                                                IID_PPV_ARGS(&heap->heap)))) {
+   if (FAILED(ID3D12Device1_CreateDescriptorHeap(device->dev, &desc,
+                                                 IID_ID3D12DescriptorHeap,
+                                                 (void **)&heap->heap))) {
       return vk_error(device,
                       shader_visible ?
                       VK_ERROR_OUT_OF_DEVICE_MEMORY : VK_ERROR_OUT_OF_HOST_MEMORY);
    }
 
-   heap->cpu_base = heap->heap->GetCPUDescriptorHandleForHeapStart().ptr;
-   if (shader_visible)
-      heap->gpu_base = heap->heap->GetGPUDescriptorHandleForHeapStart().ptr;
+   D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle;
+   ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(heap->heap, &cpu_handle);
+   heap->cpu_base = cpu_handle.ptr;
+   if (shader_visible) {
+      D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle;
+      ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(heap->heap, &gpu_handle);
+      heap->gpu_base = gpu_handle.ptr;
+   }
 
    return VK_SUCCESS;
 }
@@ -822,8 +828,8 @@ dzn_descriptor_heap_write_sampler_desc(dzn_descriptor_heap *heap,
                                        uint32_t desc_offset,
                                        const dzn_sampler *sampler)
 {
-   heap->dev->CreateSampler(&sampler->desc,
-                            dzn_descriptor_heap_get_cpu_handle(heap, desc_offset));
+   ID3D12Device1_CreateSampler(heap->dev, &sampler->desc,
+                               dzn_descriptor_heap_get_cpu_handle(heap, desc_offset));
 }
 
 void
@@ -837,7 +843,7 @@ dzn_descriptor_heap_write_image_view_desc(dzn_descriptor_heap *heap,
    dzn_image *image = container_of(iview->vk.image, dzn_image, vk);
 
    if (writeable) {
-      heap->dev->CreateUnorderedAccessView(image->res, NULL, &iview->uav_desc, view_handle);
+      ID3D12Device1_CreateUnorderedAccessView(heap->dev, image->res, NULL, &iview->uav_desc, view_handle);
    } else if (cube_as_2darray &&
               (iview->srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBEARRAY ||
                iview->srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBE)) {
@@ -862,9 +868,9 @@ dzn_descriptor_heap_write_image_view_desc(dzn_descriptor_heap *heap,
          srv_desc.Texture2DArray.ArraySize = 6;
       }
 
-      heap->dev->CreateShaderResourceView(image->res, &srv_desc, view_handle);
+      ID3D12Device1_CreateShaderResourceView(heap->dev, image->res, &srv_desc, view_handle);
    } else {
-      heap->dev->CreateShaderResourceView(image->res, &iview->srv_desc, view_handle);
+      ID3D12Device1_CreateShaderResourceView(heap->dev, image->res, &iview->srv_desc, view_handle);
    }
 }
 
@@ -878,9 +884,9 @@ dzn_descriptor_heap_write_buffer_view_desc(dzn_descriptor_heap *heap,
       dzn_descriptor_heap_get_cpu_handle(heap, desc_offset);
 
    if (writeable)
-      heap->dev->CreateUnorderedAccessView(bview->buffer->res, NULL, &bview->uav_desc, view_handle);
+      ID3D12Device1_CreateUnorderedAccessView(heap->dev, bview->buffer->res, NULL, &bview->uav_desc, view_handle);
    else
-      heap->dev->CreateShaderResourceView(bview->buffer->res, &bview->srv_desc, view_handle);
+      ID3D12Device1_CreateShaderResourceView(heap->dev, bview->buffer->res, &bview->srv_desc, view_handle);
 }
 
 void
@@ -901,10 +907,10 @@ dzn_descriptor_heap_write_buffer_desc(dzn_descriptor_heap *heap,
        info->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) {
       assert(!writeable);
       D3D12_CONSTANT_BUFFER_VIEW_DESC cbv_desc = {
-         .BufferLocation = info->buffer->res->GetGPUVirtualAddress() + info->offset,
+         .BufferLocation = ID3D12Resource_GetGPUVirtualAddress(info->buffer->res) + info->offset,
          .SizeInBytes = ALIGN_POT(size, 256),
       };
-      heap->dev->CreateConstantBufferView(&cbv_desc, view_handle);
+      ID3D12Device1_CreateConstantBufferView(heap->dev, &cbv_desc, view_handle);
    } else if (writeable) {
       D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {
          .Format = DXGI_FORMAT_R32_TYPELESS,
@@ -915,7 +921,7 @@ dzn_descriptor_heap_write_buffer_desc(dzn_descriptor_heap *heap,
             .Flags = D3D12_BUFFER_UAV_FLAG_RAW,
          },
       };
-      heap->dev->CreateUnorderedAccessView(info->buffer->res, NULL, &uav_desc, view_handle);
+      ID3D12Device1_CreateUnorderedAccessView(heap->dev, info->buffer->res, NULL, &uav_desc, view_handle);
    } else {
       D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {
          .Format = DXGI_FORMAT_R32_TYPELESS,
@@ -927,7 +933,7 @@ dzn_descriptor_heap_write_buffer_desc(dzn_descriptor_heap *heap,
             .Flags = D3D12_BUFFER_SRV_FLAG_RAW,
          },
       };
-      heap->dev->CreateShaderResourceView(info->buffer->res, &srv_desc, view_handle);
+      ID3D12Device1_CreateShaderResourceView(heap->dev, info->buffer->res, &srv_desc, view_handle);
    }
 }
 
@@ -943,10 +949,10 @@ dzn_descriptor_heap_copy(dzn_descriptor_heap *dst_heap,
    D3D12_CPU_DESCRIPTOR_HANDLE src_handle =
       dzn_descriptor_heap_get_cpu_handle(src_heap, src_offset);
 
-   dst_heap->dev->CopyDescriptorsSimple(desc_count,
-                                        dst_handle,
-                                        src_handle,
-                                        dst_heap->type);
+   ID3D12Device1_CopyDescriptorsSimple(dst_heap->dev, desc_count,
+                                       dst_handle,
+                                       src_handle,
+                                       dst_heap->type);
 }
 
 struct dzn_descriptor_set_ptr {
@@ -1423,7 +1429,7 @@ dzn_descriptor_heap_pool_init(dzn_descriptor_heap_pool *pool,
    list_inithead(&pool->active_heaps);
    list_inithead(&pool->free_heaps);
    pool->offset = 0;
-   pool->desc_sz = device->dev->GetDescriptorHandleIncrementSize(type);
+   pool->desc_sz = ID3D12Device1_GetDescriptorHandleIncrementSize(device->dev, type);
 }
 
 VkResult
diff --git a/src/microsoft/vulkan/dzn_device.cpp b/src/microsoft/vulkan/dzn_device.cpp
index 20a35af8655..3bb36700f54 100644
--- a/src/microsoft/vulkan/dzn_device.cpp
+++ b/src/microsoft/vulkan/dzn_device.cpp
@@ -43,7 +43,10 @@
 #include <stdlib.h>
 
 #include <windows.h>
+
+#define CINTERFACE
 #include <directx/d3d12sdklayers.h>
+#undef CINTERFACE
 
 #if defined(VK_USE_PLATFORM_WIN32_KHR) || \
     defined(VK_USE_PLATFORM_DISPLAY_KHR)
@@ -113,10 +116,10 @@ dzn_physical_device_destroy(dzn_physical_device *pdev)
    list_del(&pdev->link);
 
    if (pdev->dev)
-      pdev->dev->Release();
+      ID3D12Device1_Release(pdev->dev);
 
    if (pdev->adapter)
-      pdev->adapter->Release();
+      IDXGIAdapter1_Release(pdev->adapter);
 
    dzn_wsi_finish(pdev);
    vk_physical_device_finish(&pdev->vk);
@@ -236,7 +239,7 @@ dzn_physical_device_create(dzn_instance *instance,
    mtx_init(&pdev->dev_lock, mtx_plain);
    pdev->adapter_desc = *adapter_desc;
    pdev->adapter = adapter;
-   adapter->AddRef();
+   IDXGIAdapter1_AddRef(adapter);
    list_addtail(&pdev->link, &instance->physical_devices);
 
    vk_warn_non_conformant_implementation("dzn");
@@ -282,11 +285,11 @@ dzn_physical_device_cache_caps(dzn_physical_device *pdev)
       .pFeatureLevelsRequested = checklist,
    };
 
-   pdev->dev->CheckFeatureSupport(D3D12_FEATURE_FEATURE_LEVELS, &levels, sizeof(levels));
+   ID3D12Device1_CheckFeatureSupport(pdev->dev, D3D12_FEATURE_FEATURE_LEVELS, &levels, sizeof(levels));
    pdev->feature_level = levels.MaxSupportedFeatureLevel;
 
-   pdev->dev->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE1, &pdev->architecture, sizeof(pdev->architecture));
-   pdev->dev->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &pdev->options, sizeof(pdev->options));
+   ID3D12Device1_CheckFeatureSupport(pdev->dev, D3D12_FEATURE_ARCHITECTURE1, &pdev->architecture, sizeof(pdev->architecture));
+   ID3D12Device1_CheckFeatureSupport(pdev->dev, D3D12_FEATURE_D3D12_OPTIONS, &pdev->options, sizeof(pdev->options));
 
    pdev->queue_families[pdev->queue_family_count++] = {
       .props = {
@@ -337,13 +340,14 @@ dzn_physical_device_cache_caps(dzn_physical_device *pdev)
    };
 
    ID3D12CommandQueue *cmdqueue;
-   pdev->dev->CreateCommandQueue(&queue_desc,
-                                 IID_PPV_ARGS(&cmdqueue));
+   ID3D12Device1_CreateCommandQueue(pdev->dev, &queue_desc,
+                                    IID_ID3D12CommandQueue,
+                                    (void **)&cmdqueue);
 
    uint64_t ts_freq;
-   cmdqueue->GetTimestampFrequency(&ts_freq);
+   ID3D12CommandQueue_GetTimestampFrequency(cmdqueue, &ts_freq);
    pdev->timestamp_period = 1000000000.0f / ts_freq;
-   cmdqueue->Release();
+   ID3D12CommandQueue_Release(cmdqueue);
 }
 
 static void
@@ -502,8 +506,8 @@ dzn_physical_device_get_format_support(dzn_physical_device *pdev,
 
    ID3D12Device1 *dev = dzn_physical_device_get_d3d12_dev(pdev);
    HRESULT hres =
-      dev->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT,
-                               &dfmt_info, sizeof(dfmt_info));
+      ID3D12Device1_CheckFeatureSupport(dev, D3D12_FEATURE_FORMAT_SUPPORT,
+                                        &dfmt_info, sizeof(dfmt_info));
    assert(!FAILED(hres));
 
    if (usage != VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
@@ -517,7 +521,7 @@ dzn_physical_device_get_format_support(dzn_physical_device *pdev,
         .Format = dzn_image_get_dxgi_format(format, 0, aspect),
       };
 
-      hres = dev->CheckFeatureSupport(D3D12_FEATURE_FORMAT_SUPPORT,
+      hres = ID3D12Device1_CheckFeatureSupport(dev, D3D12_FEATURE_FORMAT_SUPPORT,
                                       &dfmt_info2, sizeof(dfmt_info2));
       assert(!FAILED(hres));
 
@@ -800,7 +804,7 @@ dzn_physical_device_get_image_format_properties(dzn_physical_device *pdev,
          };
 
          HRESULT hres =
-            dev->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
+            ID3D12Device1_CheckFeatureSupport(dev, D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
                                      &ms_info, sizeof(ms_info));
          if (!FAILED(hres) && ms_info.NumQualityLevels > 0)
             properties->imageFormatProperties.sampleCounts |= s;
@@ -903,12 +907,12 @@ dzn_EnumeratePhysicalDevices(VkInstance inst,
    if (!instance->physical_devices_enumerated) {
       IDXGIFactory4 *factory = dxgi_get_factory(false);
       IDXGIAdapter1 *adapter = NULL;
-      for (UINT i = 0; SUCCEEDED(factory->EnumAdapters1(i, &adapter)); ++i) {
+      for (UINT i = 0; SUCCEEDED(IDXGIFactory4_EnumAdapters1(factory, i, &adapter)); ++i) {
          DXGI_ADAPTER_DESC1 desc;
-         adapter->GetDesc1(&desc);
+         IDXGIAdapter1_GetDesc1(adapter, &desc);
          if (instance->debug_flags & DZN_DEBUG_WARP) {
             if ((desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) == 0) {
-               adapter->Release();
+               IDXGIAdapter1_Release(adapter);
                continue;
             }
          }
@@ -916,13 +920,13 @@ dzn_EnumeratePhysicalDevices(VkInstance inst,
          VkResult result =
             dzn_physical_device_create(instance, adapter, &desc);
 
-         adapter->Release();
+         IDXGIAdapter1_Release(adapter);
          if (result != VK_SUCCESS) {
-            factory->Release();
+            IDXGIFactory4_Release(factory);
             return result;
          }
       }
-      factory->Release();
+      IDXGIFactory4_Release(factory);
    }
 
    VK_OUTARRAY_MAKE_TYPED(VkPhysicalDevice, out, pPhysicalDevices,
@@ -1398,7 +1402,7 @@ dzn_queue_sync_wait(dzn_queue *queue, const struct vk_sync_wait *wait)
 
    assert(sync->fence != NULL);
 
-   if (value > 0 && FAILED(queue->cmdqueue->Wait(sync->fence, value)))
+   if (value > 0 && FAILED(ID3D12CommandQueue_Wait(queue->cmdqueue, sync->fence, value)))
       return vk_error(device, VK_ERROR_UNKNOWN);
 
    return VK_SUCCESS;
@@ -1419,7 +1423,7 @@ dzn_queue_sync_signal(dzn_queue *queue, const struct vk_sync_signal *signal)
 
    assert(sync->fence != NULL);
 
-   if (FAILED(queue->cmdqueue->Signal(sync->fence, value)))
+   if (FAILED(ID3D12CommandQueue_Signal(queue->cmdqueue, sync->fence, value)))
       return vk_error(device, VK_ERROR_UNKNOWN);
 
    return VK_SUCCESS;
@@ -1443,10 +1447,10 @@ dzn_queue_submit(struct vk_queue *q,
       dzn_cmd_buffer *cmd_buffer =
          container_of(info->command_buffers[i], dzn_cmd_buffer, vk);
 
-      ID3D12CommandList *cmdlists[] = { cmd_buffer->cmdlist };
+      ID3D12CommandList *cmdlists[] = { (ID3D12CommandList *)cmd_buffer->cmdlist };
 
       util_dynarray_foreach(&cmd_buffer->events.wait, dzn_event *, evt) {
-         if (FAILED(queue->cmdqueue->Wait((*evt)->fence, 1)))
+         if (FAILED(ID3D12CommandQueue_Wait(queue->cmdqueue, (*evt)->fence, 1)))
             return vk_error(device, VK_ERROR_UNKNOWN);
       }
 
@@ -1456,7 +1460,7 @@ dzn_queue_submit(struct vk_queue *q,
             struct dzn_query *query = &range->qpool->queries[q];
 
             if (query->fence &&
-                FAILED(queue->cmdqueue->Wait(query->fence, query->fence_value)))
+                FAILED(ID3D12CommandQueue_Wait(queue->cmdqueue, query->fence, query->fence_value)))
                return vk_error(device, VK_ERROR_UNKNOWN);
          }
          mtx_unlock(&range->qpool->queries_lock);
@@ -1467,7 +1471,7 @@ dzn_queue_submit(struct vk_queue *q,
          for (uint32_t q = range->start; q < range->start + range->count; q++) {
             struct dzn_query *query = &range->qpool->queries[q];
             if (query->fence) {
-               query->fence->Release();
+               ID3D12Fence_Release(query->fence);
                query->fence = NULL;
             }
             query->fence_value = 0;
@@ -1475,10 +1479,10 @@ dzn_queue_submit(struct vk_queue *q,
          mtx_unlock(&range->qpool->queries_lock);
       }
 
-      queue->cmdqueue->ExecuteCommandLists(1, cmdlists);
+      ID3D12CommandQueue_ExecuteCommandLists(queue->cmdqueue, 1, cmdlists);
 
       util_dynarray_foreach(&cmd_buffer->events.signal, dzn_cmd_event_signal, evt) {
-         if (FAILED(queue->cmdqueue->Signal(evt->event->fence, evt->value ? 1 : 0)))
+         if (FAILED(ID3D12CommandQueue_Signal(queue->cmdqueue, evt->event->fence, evt->value ? 1 : 0)))
             return vk_error(device, VK_ERROR_UNKNOWN);
       }
 
@@ -1488,7 +1492,7 @@ dzn_queue_submit(struct vk_queue *q,
             struct dzn_query *query = &range->qpool->queries[q];
             query->fence_value = queue->fence_point + 1;
             query->fence = queue->fence;
-            query->fence->AddRef();
+            ID3D12Fence_AddRef(query->fence);
          }
          mtx_unlock(&range->qpool->queries_lock);
       }
@@ -1500,7 +1504,7 @@ dzn_queue_submit(struct vk_queue *q,
          return vk_error(device, VK_ERROR_UNKNOWN);
    }
 
-   if (FAILED(queue->cmdqueue->Signal(queue->fence, ++queue->fence_point)))
+   if (FAILED(ID3D12CommandQueue_Signal(queue->cmdqueue, queue->fence, ++queue->fence_point)))
       return vk_error(device, VK_ERROR_UNKNOWN);
 
    return VK_SUCCESS;
@@ -1510,10 +1514,10 @@ static void
 dzn_queue_finish(dzn_queue *queue)
 {
    if (queue->cmdqueue)
-      queue->cmdqueue->Release();
+      ID3D12CommandQueue_Release(queue->cmdqueue);
 
    if (queue->fence)
-      queue->fence->Release();
+      ID3D12Fence_Release(queue->fence);
 
    vk_queue_finish(&queue->vk);
 }
@@ -1541,14 +1545,16 @@ dzn_queue_init(dzn_queue *queue,
       (INT)(pCreateInfo->pQueuePriorities[index_in_family] * (float)D3D12_COMMAND_QUEUE_PRIORITY_HIGH);
    queue_desc.NodeMask = 0;
 
-   if (FAILED(device->dev->CreateCommandQueue(&queue_desc,
-                                              IID_PPV_ARGS(&queue->cmdqueue)))) {
+   if (FAILED(ID3D12Device1_CreateCommandQueue(device->dev, &queue_desc,
+                                               IID_ID3D12CommandQueue,
+                                               (void **)&queue->cmdqueue))) {
       dzn_queue_finish(queue);
       return vk_error(device->vk.physical->instance, VK_ERROR_INITIALIZATION_FAILED);
    }
 
-   if (FAILED(device->dev->CreateFence(0, D3D12_FENCE_FLAG_NONE,
-                                       IID_PPV_ARGS(&queue->fence)))) {
+   if (FAILED(ID3D12Device1_CreateFence(device->dev, 0, D3D12_FENCE_FLAG_NONE,
+                                        IID_ID3D12Fence,
+                                        (void **)&queue->fence))) {
       dzn_queue_finish(queue);
       return vk_error(device->vk.physical->instance, VK_ERROR_INITIALIZATION_FAILED);
    }
@@ -1607,8 +1613,8 @@ static VkResult
 dzn_device_query_init(dzn_device *device)
 {
    /* FIXME: create the resource in the default heap */
-   D3D12_HEAP_PROPERTIES hprops =
-      device->dev->GetCustomHeapProperties(0, D3D12_HEAP_TYPE_UPLOAD);
+   D3D12_HEAP_PROPERTIES hprops;
+   ID3D12Device1_GetCustomHeapProperties(device->dev, &hprops, 0, D3D12_HEAP_TYPE_UPLOAD);
    D3D12_RESOURCE_DESC rdesc = {
       .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
       .Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
@@ -1622,21 +1628,22 @@ dzn_device_query_init(dzn_device *device)
       .Flags = D3D12_RESOURCE_FLAG_NONE,
    };
 
-   if (FAILED(device->dev->CreateCommittedResource(&hprops,
+   if (FAILED(ID3D12Device1_CreateCommittedResource(device->dev, &hprops,
                                                    D3D12_HEAP_FLAG_NONE,
                                                    &rdesc,
                                                    D3D12_RESOURCE_STATE_GENERIC_READ,
                                                    NULL,
-                                                   IID_PPV_ARGS(&device->queries.refs))))
+                                                   IID_ID3D12Resource,
+                                                   (void **)&device->queries.refs)))
       return vk_error(device->vk.physical, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    uint8_t *queries_ref;
-   if (FAILED(device->queries.refs->Map(0, NULL, (void **)&queries_ref)))
+   if (FAILED(ID3D12Resource_Map(device->queries.refs, 0, NULL, (void **)&queries_ref)))
       return vk_error(device->vk.physical, VK_ERROR_OUT_OF_HOST_MEMORY);
 
    memset(queries_ref + DZN_QUERY_REFS_ALL_ONES_OFFSET, 0xff, DZN_QUERY_REFS_SECTION_SIZE);
    memset(queries_ref + DZN_QUERY_REFS_ALL_ZEROS_OFFSET, 0x0, DZN_QUERY_REFS_SECTION_SIZE);
-   device->queries.refs->Unmap(0, NULL);
+   ID3D12Resource_Unmap(device->queries.refs, 0, NULL);
 
    return VK_SUCCESS;
 }
@@ -1645,7 +1652,7 @@ static void
 dzn_device_query_finish(dzn_device *device)
 {
    if (device->queries.refs)
-      device->queries.refs->Release();
+      ID3D12Resource_Release(device->queries.refs);
 }
 
 static void
@@ -1667,7 +1674,7 @@ dzn_device_destroy(dzn_device *device, const VkAllocationCallbacks *pAllocator)
    dzn_meta_finish(device);
 
    if (device->dev)
-      device->dev->Release();
+      ID3D12Device1_Release(device->dev);
 
    vk_device_finish(&device->vk);
    vk_free2(&instance->vk.alloc, pAllocator, device);
@@ -1736,10 +1743,11 @@ dzn_device_create(dzn_physical_device *pdev,
       return vk_error(pdev, VK_ERROR_INITIALIZATION_FAILED);
    }
 
-   device->dev->AddRef();
+   ID3D12Device1_AddRef(device->dev);
 
    ID3D12InfoQueue *info_queue;
-   if (SUCCEEDED(device->dev->QueryInterface(IID_PPV_ARGS(&info_queue)))) {
+   if (SUCCEEDED(ID3D12Device1_QueryInterface(device->dev, IID_ID3D12InfoQueue,
+                                              (void **)&info_queue))) {
       D3D12_MESSAGE_SEVERITY severities[] = {
          D3D12_MESSAGE_SEVERITY_INFO,
          D3D12_MESSAGE_SEVERITY_WARNING,
@@ -1755,7 +1763,7 @@ dzn_device_create(dzn_physical_device *pdev,
       NewFilter.DenyList.NumIDs = ARRAY_SIZE(msg_ids);
       NewFilter.DenyList.pIDList = msg_ids;
 
-      info_queue->PushStorageFilter(&NewFilter);
+      ID3D12InfoQueue_PushStorageFilter(info_queue, &NewFilter);
    }
 
    result = dzn_meta_init(device);
@@ -1800,7 +1808,7 @@ dzn_device_create_root_sig(dzn_device *device,
    if (FAILED(instance->d3d12.serialize_root_sig(desc,
                                                  &sig, &error))) {
       if (instance->debug_flags & DZN_DEBUG_SIG) {
-         const char* error_msg = (const char*)error->GetBufferPointer();
+         const char* error_msg = (const char*)ID3D10Blob_GetBufferPointer(error);
          fprintf(stderr,
                  "== SERIALIZE ROOT SIG ERROR =============================================\n"
                  "%s\n"
@@ -1808,20 +1816,21 @@ dzn_device_create_root_sig(dzn_device *device,
                  error_msg);
       }
 
-      error->Release();
+      ID3D10Blob_Release(error);
       return NULL;
    }
 
    ID3D12RootSignature *root_sig;
-   if (FAILED(device->dev->CreateRootSignature(0,
-                                               sig->GetBufferPointer(),
-                                               sig->GetBufferSize(),
-                                               IID_PPV_ARGS(&root_sig)))) {
-      sig->Release();
+   if (FAILED(ID3D12Device1_CreateRootSignature(device->dev, 0,
+                                                ID3D10Blob_GetBufferPointer(sig),
+                                                ID3D10Blob_GetBufferSize(sig),
+                                                IID_ID3D12RootSignature,
+                                                (void **)&root_sig))) {
+      ID3D10Blob_Release(sig);
       return NULL;
    }
 
-   sig->Release();
+   ID3D10Blob_Release(sig);
    return root_sig;
 }
 
@@ -1879,13 +1888,13 @@ dzn_device_memory_destroy(dzn_device_memory *mem,
    dzn_device *device = container_of(mem->base.device, dzn_device, vk);
 
    if (mem->map)
-      mem->map_res->Unmap(0, NULL);
+      ID3D12Resource_Unmap(mem->map_res, 0, NULL);
 
    if (mem->map_res)
-      mem->map_res->Release();
+      ID3D12Resource_Release(mem->map_res);
 
    if (mem->heap)
-      mem->heap->Release();
+      ID3D12Heap_Release(mem->heap);
 
    vk_object_base_finish(&mem->base);
    vk_free2(&device->vk.alloc, pAllocator, mem);
@@ -1951,7 +1960,9 @@ dzn_device_memory_create(dzn_device *device,
       heap_desc.Properties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE;
    }
 
-   if (FAILED(device->dev->CreateHeap(&heap_desc, IID_PPV_ARGS(&mem->heap)))) {
+   if (FAILED(ID3D12Device1_CreateHeap(device->dev, &heap_desc,
+                                       IID_ID3D12Heap,
+                                       (void **)&mem->heap))) {
       dzn_device_memory_destroy(mem, pAllocator);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
    }
@@ -1970,9 +1981,11 @@ dzn_device_memory_create(dzn_device *device,
       res_desc.SampleDesc.Quality = 0;
       res_desc.Flags = D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
       res_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-      HRESULT hr = device->dev->CreatePlacedResource(mem->heap, 0, &res_desc,
-                                                     mem->initial_state,
-                                                     NULL, IID_PPV_ARGS(&mem->map_res));
+      HRESULT hr = ID3D12Device1_CreatePlacedResource(device->dev, mem->heap, 0, &res_desc,
+                                                      mem->initial_state,
+                                                      NULL,
+                                                      IID_ID3D12Resource,
+                                                      (void **)&mem->map_res);
       if (FAILED(hr)) {
          dzn_device_memory_destroy(mem, pAllocator);
          return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@@ -2035,7 +2048,7 @@ dzn_MapMemory(VkDevice _device,
    range.Begin = offset;
    range.End = offset + size;
    void *map = NULL;
-   if (FAILED(mem->map_res->Map(0, &range, &map)))
+   if (FAILED(ID3D12Resource_Map(mem->map_res, 0, &range, &map)))
       return vk_error(device, VK_ERROR_MEMORY_MAP_FAILED);
 
    mem->map = map;
@@ -2057,7 +2070,7 @@ dzn_UnmapMemory(VkDevice _device,
       return;
 
    assert(mem->map_res);
-   mem->map_res->Unmap(0, NULL);
+   ID3D12Resource_Unmap(mem->map_res, 0, NULL);
 
    mem->map = NULL;
    mem->map_size = 0;
@@ -2088,7 +2101,7 @@ dzn_buffer_destroy(dzn_buffer *buf, const VkAllocationCallbacks *pAllocator)
    dzn_device *device = container_of(buf->base.device, dzn_device, vk);
 
    if (buf->res)
-      buf->res->Release();
+      ID3D12Resource_Release(buf->res);
 
    vk_object_base_finish(&buf->base);
    vk_free2(&device->vk.alloc, pAllocator, buf);
@@ -2319,11 +2332,13 @@ dzn_BindBufferMemory2(VkDevice _device,
       VK_FROM_HANDLE(dzn_device_memory, mem, pBindInfos[i].memory);
       VK_FROM_HANDLE(dzn_buffer, buffer, pBindInfos[i].buffer);
 
-      if (FAILED(device->dev->CreatePlacedResource(mem->heap,
+      if (FAILED(ID3D12Device1_CreatePlacedResource(device->dev, mem->heap,
                                                    pBindInfos[i].memoryOffset,
                                                    &buffer->desc,
                                                    mem->initial_state,
-                                                   NULL, IID_PPV_ARGS(&buffer->res))))
+                                                   NULL,
+                                                   IID_ID3D12Resource,
+                                                   (void **)&buffer->res)))
          return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
 
@@ -2403,7 +2418,7 @@ dzn_event_destroy(dzn_event *event,
       container_of(event->base.device, dzn_device, vk);
 
    if (event->fence)
-      event->fence->Release();
+      ID3D12Fence_Release(event->fence);
 
    vk_object_base_finish(&event->base);
    vk_free2(&device->vk.alloc, pAllocator, event);
@@ -2423,8 +2438,9 @@ dzn_event_create(dzn_device *device,
 
    vk_object_base_init(&device->vk, &event->base, VK_OBJECT_TYPE_EVENT);
 
-   if (FAILED(device->dev->CreateFence(0, D3D12_FENCE_FLAG_NONE,
-                                       IID_PPV_ARGS(&event->fence)))) {
+   if (FAILED(ID3D12Device1_CreateFence(device->dev, 0, D3D12_FENCE_FLAG_NONE,
+                                        IID_ID3D12Fence,
+                                        (void **)&event->fence))) {
       dzn_event_destroy(event, pAllocator);
       return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
@@ -2458,7 +2474,7 @@ dzn_ResetEvent(VkDevice dev,
    VK_FROM_HANDLE(dzn_device, device, dev);
    VK_FROM_HANDLE(dzn_event, event, evt);
 
-   if (FAILED(event->fence->Signal(0)))
+   if (FAILED(ID3D12Fence_Signal(event->fence, 0)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -2471,7 +2487,7 @@ dzn_SetEvent(VkDevice dev,
    VK_FROM_HANDLE(dzn_device, device, dev);
    VK_FROM_HANDLE(dzn_event, event, evt);
 
-   if (FAILED(event->fence->Signal(1)))
+   if (FAILED(ID3D12Fence_Signal(event->fence, 1)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -2483,7 +2499,7 @@ dzn_GetEventStatus(VkDevice device,
 {
    VK_FROM_HANDLE(dzn_event, event, evt);
 
-   return event->fence->GetCompletedValue() == 0 ?
+   return ID3D12Fence_GetCompletedValue(event->fence) == 0 ?
           VK_EVENT_RESET : VK_EVENT_SET;
 }
 
diff --git a/src/microsoft/vulkan/dzn_image.cpp b/src/microsoft/vulkan/dzn_image.cpp
index f2b1d9f0092..4e9ec6580ad 100644
--- a/src/microsoft/vulkan/dzn_image.cpp
+++ b/src/microsoft/vulkan/dzn_image.cpp
@@ -38,7 +38,7 @@ dzn_image_destroy(dzn_image *image,
    dzn_device *device = container_of(image->vk.base.device, dzn_device, vk);
 
    if (image->res)
-      image->res->Release();
+      ID3D12Resource_Release(image->res);
 
    vk_image_finish(&image->vk);
    vk_free2(&device->vk.alloc, pAllocator, image);
@@ -126,7 +126,7 @@ dzn_image_create(dzn_device *device,
       };
       D3D12_PLACED_SUBRESOURCE_FOOTPRINT footprint;
       uint64_t size = 0;
-      device->dev->GetCopyableFootprints(&tmp_desc, 0, 1, 0, &footprint, NULL, NULL, &size);
+      ID3D12Device1_GetCopyableFootprints(device->dev, &tmp_desc, 0, 1, 0, &footprint, NULL, NULL, &size);
 
       image->linear.row_stride = footprint.Footprint.RowPitch;
       image->linear.size = size;
@@ -630,11 +630,13 @@ dzn_BindImageMemory2(VkDevice dev,
       if (!did_bind) {
          image->mem = mem;
          image->mem_offset = bind_info->memoryOffset;
-         if (FAILED(device->dev->CreatePlacedResource(mem->heap,
+         if (FAILED(ID3D12Device1_CreatePlacedResource(device->dev, mem->heap,
                                                       bind_info->memoryOffset,
                                                       &image->desc,
                                                       mem->initial_state,
-                                                      NULL, IID_PPV_ARGS(&image->res))))
+                                                      NULL,
+                                                      IID_ID3D12Resource,
+                                                      (void **)&image->res)))
             return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
          did_bind = true;
       }
@@ -674,7 +676,8 @@ dzn_GetImageMemoryRequirements2(VkDevice _device,
       }
    }
 
-   D3D12_RESOURCE_ALLOCATION_INFO info = device->dev->GetResourceAllocationInfo(0, 1, &image->desc);
+   D3D12_RESOURCE_ALLOCATION_INFO info;
+   ID3D12Device1_GetResourceAllocationInfo(device->dev, &info, 0, 1, &image->desc);
 
    pMemoryRequirements->memoryRequirements = VkMemoryRequirements {
       .size = info.SizeInBytes,
@@ -720,7 +723,7 @@ dzn_GetImageSubresourceLayout(VkDevice _device,
       D3D12_PLACED_SUBRESOURCE_FOOTPRINT footprint;
       UINT num_rows;
       UINT64 row_size, total_size;
-      device->dev->GetCopyableFootprints(&image->desc,
+      ID3D12Device1_GetCopyableFootprints(device->dev, &image->desc,
                                          subres_index, 1,
                                          0, // base-offset?
                                          &footprint,
diff --git a/src/microsoft/vulkan/dzn_meta.cpp b/src/microsoft/vulkan/dzn_meta.cpp
index 09986658be3..5fffe4f3e25 100644
--- a/src/microsoft/vulkan/dzn_meta.cpp
+++ b/src/microsoft/vulkan/dzn_meta.cpp
@@ -95,10 +95,10 @@ dzn_meta_indirect_draw_finish(dzn_device *device, enum dzn_indirect_draw_type ty
    dzn_meta_indirect_draw *meta = &device->indirect_draws[type];
 
    if (meta->root_sig)
-      meta->root_sig->Release();
+      ID3D12RootSignature_Release(meta->root_sig);
 
    if (meta->pipeline_state)
-      meta->pipeline_state->Release();
+      ID3D12PipelineState_Release(meta->pipeline_state);
 }
 
 static VkResult
@@ -192,8 +192,9 @@ dzn_meta_indirect_draw_init(dzn_device *device,
    dzn_meta_compile_shader(device, nir, &desc.CS);
    assert(desc.CS.pShaderBytecode);
 
-   if (FAILED(device->dev->CreateComputePipelineState(&desc,
-                                                      IID_PPV_ARGS(&meta->pipeline_state))))
+   if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
+                                                       IID_ID3D12PipelineState,
+                                                       (void **)&meta->pipeline_state)))
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
 
 out:
@@ -217,11 +218,11 @@ dzn_meta_triangle_fan_rewrite_index_finish(dzn_device *device,
       &device->triangle_fan[old_index_type];
 
    if (meta->root_sig)
-      meta->root_sig->Release();
+      ID3D12RootSignature_Release(meta->root_sig);
    if (meta->pipeline_state)
-      meta->pipeline_state->Release();
+      ID3D12PipelineState_Release(meta->pipeline_state);
    if (meta->cmd_sig)
-      meta->cmd_sig->Release();
+      ID3D12CommandSignature_Release(meta->cmd_sig);
 }
 
 static VkResult
@@ -328,15 +329,17 @@ dzn_meta_triangle_fan_rewrite_index_init(dzn_device *device,
    desc.pRootSignature = meta->root_sig;
    dzn_meta_compile_shader(device, nir, &desc.CS);
 
-   if (FAILED(device->dev->CreateComputePipelineState(&desc,
-                                                      IID_PPV_ARGS(&meta->pipeline_state)))) {
+   if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
+                                                       IID_ID3D12PipelineState,
+                                                       (void **)&meta->pipeline_state))) {
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
       goto out;
    }
 
-   if (FAILED(device->dev->CreateCommandSignature(&cmd_sig_desc,
-                                                  meta->root_sig,
-                                                  IID_PPV_ARGS(&meta->cmd_sig))))
+   if (FAILED(ID3D12Device1_CreateCommandSignature(device->dev, &cmd_sig_desc,
+                                                   meta->root_sig,
+                                                   IID_ID3D12CommandSignature,
+                                                   (void **)&meta->cmd_sig)))
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
 
 out:
@@ -451,9 +454,9 @@ dzn_meta_blit_destroy(dzn_device *device, dzn_meta_blit *blit)
       return;
 
    if (blit->root_sig)
-      blit->root_sig->Release();
+      ID3D12RootSignature_Release(blit->root_sig);
    if (blit->pipeline_state)
-      blit->pipeline_state->Release();
+      ID3D12PipelineState_Release(blit->pipeline_state);
 
    vk_free(&device->vk.alloc, blit);
 }
@@ -608,8 +611,9 @@ dzn_meta_blit_create(dzn_device *device, const dzn_meta_blit_key *key)
       }
    }
 
-   if (FAILED(device->dev->CreateGraphicsPipelineState(&desc,
-                                                       IID_PPV_ARGS(&blit->pipeline_state)))) {
+   if (FAILED(ID3D12Device1_CreateGraphicsPipelineState(device->dev, &desc,
+                                                        IID_ID3D12PipelineState,
+                                                        (void **)&blit->pipeline_state))) {
       dzn_meta_blit_destroy(device, blit);
       return NULL;
    }
diff --git a/src/microsoft/vulkan/dzn_nir.h b/src/microsoft/vulkan/dzn_nir.h
index f3aced31a71..5f352c54bbb 100644
--- a/src/microsoft/vulkan/dzn_nir.h
+++ b/src/microsoft/vulkan/dzn_nir.h
@@ -25,7 +25,10 @@
 #define DZN_NIR_H
 
 #define D3D12_IGNORE_SDK_LAYERS
+#define CINTERFACE
+#define COBJMACROS
 #include <directx/d3d12.h>
+#undef CINTERFACE
 
 #include "nir.h"
 
diff --git a/src/microsoft/vulkan/dzn_pipeline.cpp b/src/microsoft/vulkan/dzn_pipeline.cpp
index 9d2a3064eda..3338e560041 100644
--- a/src/microsoft/vulkan/dzn_pipeline.cpp
+++ b/src/microsoft/vulkan/dzn_pipeline.cpp
@@ -716,7 +716,7 @@ dzn_pipeline_init(dzn_pipeline *pipeline,
    STATIC_ASSERT(sizeof(pipeline->root.type) == sizeof(layout->root.type));
    memcpy(pipeline->root.type, layout->root.type, sizeof(pipeline->root.type));
    pipeline->root.sig = layout->root.sig;
-   pipeline->root.sig->AddRef();
+   ID3D12RootSignature_AddRef(pipeline->root.sig);
 
    STATIC_ASSERT(sizeof(layout->desc_count) == sizeof(pipeline->desc_count));
    memcpy(pipeline->desc_count, layout->desc_count, sizeof(pipeline->desc_count));
@@ -730,9 +730,9 @@ static void
 dzn_pipeline_finish(dzn_pipeline *pipeline)
 {
    if (pipeline->state)
-      pipeline->state->Release();
+      ID3D12PipelineState_Release(pipeline->state);
    if (pipeline->root.sig)
-      pipeline->root.sig->Release();
+      ID3D12RootSignature_Release(pipeline->root.sig);
 
    vk_object_base_finish(&pipeline->base);
 }
@@ -746,7 +746,7 @@ dzn_graphics_pipeline_destroy(dzn_graphics_pipeline *pipeline,
 
    for (uint32_t i = 0; i < ARRAY_SIZE(pipeline->indirect_cmd_sigs); i++) {
       if (pipeline->indirect_cmd_sigs[i])
-         pipeline->indirect_cmd_sigs[i]->Release();
+         ID3D12CommandSignature_Release(pipeline->indirect_cmd_sigs[i]);
    }
 
    dzn_pipeline_finish(&pipeline->base);
@@ -904,8 +904,9 @@ dzn_graphics_pipeline_create(dzn_device *device,
    }
 
 
-   hres = device->dev->CreateGraphicsPipelineState(&desc,
-                                                   IID_PPV_ARGS(&pipeline->base.state));
+   hres = ID3D12Device1_CreateGraphicsPipelineState(device->dev, &desc,
+                                                    IID_ID3D12PipelineState,
+                                                    (void **)&pipeline->base.state);
    if (FAILED(hres)) {
       ret = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
@@ -983,9 +984,10 @@ dzn_graphics_pipeline_get_indirect_cmd_sig(dzn_graphics_pipeline *pipeline,
       .pArgumentDescs = cmd_args,
    };
    HRESULT hres =
-      device->dev->CreateCommandSignature(&cmd_sig_desc,
-                                          pipeline->base.root.sig,
-                                          IID_PPV_ARGS(&cmdsig));
+      ID3D12Device1_CreateCommandSignature(device->dev, &cmd_sig_desc,
+                                           pipeline->base.root.sig,
+                                           IID_ID3D12CommandSignature,
+                                           (void **)&cmdsig);
    if (FAILED(hres))
       return NULL;
 
@@ -1039,7 +1041,7 @@ dzn_compute_pipeline_destroy(dzn_compute_pipeline *pipeline,
       return;
 
    if (pipeline->indirect_cmd_sig)
-      pipeline->indirect_cmd_sig->Release();
+      ID3D12CommandSignature_Release(pipeline->indirect_cmd_sig);
 
    dzn_pipeline_finish(&pipeline->base);
    vk_free2(&pipeline->base.base.device->alloc, alloc, pipeline);
@@ -1077,8 +1079,9 @@ dzn_compute_pipeline_create(dzn_device *device,
    if (ret != VK_SUCCESS)
       goto out;
 
-   if (FAILED(device->dev->CreateComputePipelineState(&desc,
-                                                      IID_PPV_ARGS(&pipeline->base.state)))) {
+   if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
+                                                       IID_ID3D12PipelineState,
+                                                       (void **)&pipeline->base.state))) {
       ret = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
@@ -1123,9 +1126,10 @@ dzn_compute_pipeline_get_indirect_cmd_sig(dzn_compute_pipeline *pipeline)
    };
 
    HRESULT hres =
-      device->dev->CreateCommandSignature(&indirect_dispatch_desc,
-                                          pipeline->base.root.sig,
-                                          IID_PPV_ARGS(&pipeline->indirect_cmd_sig));
+      ID3D12Device1_CreateCommandSignature(device->dev, &indirect_dispatch_desc,
+                                           pipeline->base.root.sig,
+                                           IID_ID3D12CommandSignature,
+                                           (void **)&pipeline->indirect_cmd_sig);
    if (FAILED(hres))
       return NULL;
 
diff --git a/src/microsoft/vulkan/dzn_private.h b/src/microsoft/vulkan/dzn_private.h
index e7e0ee57b0a..9c497b8e64d 100644
--- a/src/microsoft/vulkan/dzn_private.h
+++ b/src/microsoft/vulkan/dzn_private.h
@@ -51,10 +51,12 @@
 #include <vulkan/vulkan.h>
 #include <vulkan/vk_icd.h>
 
-#include <dxgi1_4.h>
-
 #define D3D12_IGNORE_SDK_LAYERS
+#define CINTERFACE
+#define COBJMACROS
+#include <dxgi1_4.h>
 #include <directx/d3d12.h>
+#undef CINTERFACE
 
 #include "spirv_to_dxil.h"
 
diff --git a/src/microsoft/vulkan/dzn_query.cpp b/src/microsoft/vulkan/dzn_query.cpp
index cecf0aed4f4..cd1e16ce3d9 100644
--- a/src/microsoft/vulkan/dzn_query.cpp
+++ b/src/microsoft/vulkan/dzn_query.cpp
@@ -62,20 +62,20 @@ dzn_query_pool_destroy(dzn_query_pool *qpool,
    dzn_device *device = container_of(qpool->base.device, dzn_device, vk);
 
    if (qpool->collect_map)
-      qpool->collect_buffer->Unmap(0, NULL);
+      ID3D12Resource_Unmap(qpool->collect_buffer, 0, NULL);
 
    if (qpool->collect_buffer)
-      qpool->collect_buffer->Release();
+      ID3D12Resource_Release(qpool->collect_buffer);
 
    if (qpool->resolve_buffer)
-      qpool->resolve_buffer->Release();
+      ID3D12Resource_Release(qpool->resolve_buffer);
 
    if (qpool->heap)
-      qpool->heap->Release();
+      ID3D12QueryHeap_Release(qpool->heap);
 
    for (uint32_t q = 0; q < qpool->query_count; q++) {
       if (qpool->queries[q].fence)
-         qpool->queries[q].fence->Release();
+         ID3D12Fence_Release(qpool->queries[q].fence);
    }
 
    mtx_destroy(&qpool->queries_lock);
@@ -109,7 +109,9 @@ dzn_query_pool_create(dzn_device *device,
    desc.NodeMask = 0;
 
    HRESULT hres =
-      device->dev->CreateQueryHeap(&desc, IID_PPV_ARGS(&qpool->heap));
+      ID3D12Device1_CreateQueryHeap(device->dev, &desc,
+                                    IID_ID3D12QueryHeap,
+                                    (void **)&qpool->heap);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@@ -127,8 +129,9 @@ dzn_query_pool_create(dzn_device *device,
    default: unreachable("Unsupported query type");
    }
 
-   D3D12_HEAP_PROPERTIES hprops =
-      device->dev->GetCustomHeapProperties(0, D3D12_HEAP_TYPE_DEFAULT);
+   D3D12_HEAP_PROPERTIES hprops;
+   ID3D12Device1_GetCustomHeapProperties(device->dev, &hprops, 0,
+                                         D3D12_HEAP_TYPE_DEFAULT);
    D3D12_RESOURCE_DESC rdesc = {
       .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
       .Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
@@ -142,29 +145,34 @@ dzn_query_pool_create(dzn_device *device,
       .Flags = D3D12_RESOURCE_FLAG_NONE,
    };
 
-   hres = device->dev->CreateCommittedResource(&hprops,
-                                               D3D12_HEAP_FLAG_NONE,
-                                               &rdesc,
-                                               D3D12_RESOURCE_STATE_COPY_DEST,
-                                               NULL, IID_PPV_ARGS(&qpool->resolve_buffer));
+   hres = ID3D12Device1_CreateCommittedResource(device->dev, &hprops,
+                                                D3D12_HEAP_FLAG_NONE,
+                                                &rdesc,
+                                                D3D12_RESOURCE_STATE_COPY_DEST,
+                                                NULL,
+                                                IID_ID3D12Resource,
+                                                (void **)&qpool->resolve_buffer);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
    }
 
-   hprops = device->dev->GetCustomHeapProperties(0, D3D12_HEAP_TYPE_READBACK);
+   ID3D12Device1_GetCustomHeapProperties(device->dev, &hprops, 0,
+                                         D3D12_HEAP_TYPE_READBACK);
    rdesc.Width = info->queryCount * (qpool->query_size + sizeof(uint64_t));
-   hres = device->dev->CreateCommittedResource(&hprops,
-                                               D3D12_HEAP_FLAG_NONE,
-                                               &rdesc,
-                                               D3D12_RESOURCE_STATE_COPY_DEST,
-                                               NULL, IID_PPV_ARGS(&qpool->collect_buffer));
+   hres = ID3D12Device1_CreateCommittedResource(device->dev, &hprops,
+                                                D3D12_HEAP_FLAG_NONE,
+                                                &rdesc,
+                                                D3D12_RESOURCE_STATE_COPY_DEST,
+                                                NULL,
+                                                IID_ID3D12Resource,
+                                                (void **)&qpool->collect_buffer);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
    }
 
-   hres = qpool->collect_buffer->Map(0, NULL, (void **)&qpool->collect_map);
+   hres = ID3D12Resource_Map(qpool->collect_buffer, 0, NULL, (void **)&qpool->collect_map);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -226,7 +234,7 @@ dzn_ResetQueryPool(VkDevice device,
 
       query->fence_value = 0;
       if (query->fence) {
-         query->fence->Release();
+         ID3D12Fence_Release(query->fence);
          query->fence = NULL;
       }
    }
@@ -271,7 +279,7 @@ dzn_GetQueryPoolResults(VkDevice device,
             mtx_lock(&qpool->queries_lock);
             if (query->fence) {
                query_fence = query->fence;
-               query_fence->AddRef();
+               ID3D12Fence_AddRef(query_fence);
             }
             query_fence_val = query->fence_value;
             mtx_unlock(&qpool->queries_lock);
@@ -285,23 +293,23 @@ dzn_GetQueryPoolResults(VkDevice device,
             Sleep(10);
          }
 
-         query_fence->SetEventOnCompletion(query_fence_val, NULL);
-         query_fence->Release();
+         ID3D12Fence_SetEventOnCompletion(query_fence, query_fence_val, NULL);
+         ID3D12Fence_Release(query_fence);
          available = UINT64_MAX;
       } else {
          ID3D12Fence *query_fence = NULL;
          mtx_lock(&qpool->queries_lock);
          if (query->fence) {
             query_fence = query->fence;
-            query_fence->AddRef();
+            ID3D12Fence_AddRef(query_fence);
          }
          uint64_t query_fence_val = query->fence_value;
          mtx_unlock(&qpool->queries_lock);
 
          if (query_fence) {
-            if (query_fence->GetCompletedValue() >= query_fence_val)
+            if (ID3D12Fence_GetCompletedValue(query_fence) >= query_fence_val)
                available = UINT64_MAX;
-            query_fence->Release();
+            ID3D12Fence_Release(query_fence);
          }
       }
 
diff --git a/src/microsoft/vulkan/dzn_sync.cpp b/src/microsoft/vulkan/dzn_sync.cpp
index 583543f72d7..249576a5fd4 100644
--- a/src/microsoft/vulkan/dzn_sync.cpp
+++ b/src/microsoft/vulkan/dzn_sync.cpp
@@ -40,8 +40,10 @@ dzn_sync_init(struct vk_device *device,
 
    assert(!(sync->flags & VK_SYNC_IS_SHAREABLE));
 
-   if (FAILED(ddev->dev->CreateFence(initial_value, D3D12_FENCE_FLAG_NONE,
-                                     IID_PPV_ARGS(&dsync->fence))))
+   if (FAILED(ID3D12Device1_CreateFence(ddev->dev, initial_value,
+                                        D3D12_FENCE_FLAG_NONE,
+                                        IID_ID3D12Fence,
+                                        (void **)&dsync->fence)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -53,7 +55,7 @@ dzn_sync_finish(struct vk_device *device,
 {
    dzn_sync *dsync = container_of(sync, dzn_sync, vk);
 
-   dsync->fence->Release();
+   ID3D12Fence_Release(dsync->fence);
 }
 
 static VkResult
@@ -66,7 +68,7 @@ dzn_sync_signal(struct vk_device *device,
    if (!(sync->flags & VK_SYNC_IS_TIMELINE))
       value = 1;
 
-   if (FAILED(dsync->fence->Signal(value)))
+   if (FAILED(ID3D12Fence_Signal(dsync->fence, value)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -79,7 +81,7 @@ dzn_sync_get_value(struct vk_device *device,
 {
    dzn_sync *dsync = container_of(sync, dzn_sync, vk);
 
-   *value = dsync->fence->GetCompletedValue();
+   *value = ID3D12Fence_GetCompletedValue(dsync->fence);
    return VK_SUCCESS;
 }
 
@@ -89,7 +91,7 @@ dzn_sync_reset(struct vk_device *device,
 {
    dzn_sync *dsync = container_of(sync, dzn_sync, vk);
 
-   if (FAILED(dsync->fence->Signal(0)))
+   if (FAILED(ID3D12Fence_Signal(dsync->fence, 0)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -105,11 +107,13 @@ dzn_sync_move(struct vk_device *device,
    dzn_sync *dsrc = container_of(src, dzn_sync, vk);
    ID3D12Fence *new_fence;
 
-   if (FAILED(ddev->dev->CreateFence(0, D3D12_FENCE_FLAG_NONE,
-                                     IID_PPV_ARGS(&new_fence))))
+   if (FAILED(ID3D12Device1_CreateFence(ddev->dev, 0,
+                                        D3D12_FENCE_FLAG_NONE,
+                                        IID_ID3D12Fence,
+                                        (void **)&new_fence)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
-   ddst->fence->Release();
+   ID3D12Fence_Release(ddst->fence);
    ddst->fence = dsrc->fence;
    dsrc->fence = new_fence;
    return VK_SUCCESS;
@@ -143,9 +147,12 @@ dzn_sync_wait(struct vk_device *device,
       D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY :
       D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL;
 
-   if (FAILED(ddev->dev->SetEventOnMultipleFenceCompletion(fences, values,
-                                                           wait_count, flags,
-                                                           event))) {
+   if (FAILED(ID3D12Device1_SetEventOnMultipleFenceCompletion(ddev->dev,
+                                                              fences,
+                                                              values,
+                                                              wait_count,
+                                                              flags,
+                                                              event))) {
       STACK_ARRAY_FINISH(fences);
       STACK_ARRAY_FINISH(values);
       CloseHandle(event);
diff --git a/src/microsoft/vulkan/dzn_util.cpp b/src/microsoft/vulkan/dzn_util.cpp
index 9f0924f238d..5128c34ce5c 100644
--- a/src/microsoft/vulkan/dzn_util.cpp
+++ b/src/microsoft/vulkan/dzn_util.cpp
@@ -28,7 +28,9 @@
 #include <stdarg.h>
 #include <stdio.h>
 
+#define CINTERFACE
 #include <directx/d3d12sdklayers.h>
+#undef CINTERFACE
 
 IDXGIFactory4 *
 dxgi_get_factory(bool debug)
@@ -86,7 +88,7 @@ get_debug_interface()
    }
 
    ID3D12Debug *debug;
-   if (FAILED(D3D12GetDebugInterface(IID_PPV_ARGS(&debug)))) {
+   if (FAILED(D3D12GetDebugInterface(IID_ID3D12Debug, (void **)&debug))) {
       mesa_loge("D3D12GetDebugInterface failed\n");
       return NULL;
    }
@@ -99,8 +101,8 @@ d3d12_enable_debug_layer()
 {
    ID3D12Debug *debug = get_debug_interface();
    if (debug) {
-      debug->EnableDebugLayer();
-      debug->Release();
+      ID3D12Debug_EnableDebugLayer(debug);
+      ID3D12Debug_Release(debug);
    }
 }
 
@@ -110,18 +112,20 @@ d3d12_enable_gpu_validation()
    ID3D12Debug *debug = get_debug_interface();
    if (debug) {
       ID3D12Debug3 *debug3;
-      if (SUCCEEDED(debug->QueryInterface(IID_PPV_ARGS(&debug3)))) {
-         debug3->SetEnableGPUBasedValidation(true);
-         debug3->Release();
+      if (SUCCEEDED(ID3D12Debug_QueryInterface(debug,
+                                               IID_ID3D12Debug3,
+                                               (void **)&debug3))) {
+         ID3D12Debug3_SetEnableGPUBasedValidation(debug3, true);
+         ID3D12Debug3_Release(debug3);
       }
-      debug->Release();
+      ID3D12Debug_Release(debug);
    }
 }
 
 ID3D12Device1 *
 d3d12_create_device(IDXGIAdapter1 *adapter, bool experimental_features)
 {
-   typedef HRESULT(WINAPI *PFN_D3D12CREATEDEVICE)(IUnknown*, D3D_FEATURE_LEVEL, REFIID, void**);
+   typedef HRESULT(WINAPI *PFN_D3D12CREATEDEVICE)(IDXGIAdapter1*, D3D_FEATURE_LEVEL, REFIID, void**);
    PFN_D3D12CREATEDEVICE D3D12CreateDevice;
 
    HMODULE d3d12_mod = LoadLibraryA("D3D12.DLL");
@@ -151,7 +155,8 @@ d3d12_create_device(IDXGIAdapter1 *adapter, bool experimental_features)
 
    ID3D12Device1 *dev;
    if (SUCCEEDED(D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0,
-                 IID_PPV_ARGS(&dev))))
+                 IID_ID3D12Device1,
+                 (void **)&dev)))
       return dev;
 
    mesa_loge("D3D12CreateDevice failed\n");