dzn: port code to plain c

This does quite a lot in one go, simply because C and C++ are too
different to cleanly move from one language to another. But hopefully
this won't create too many rebase-issues.

Reviewed-by: Boris Brezillon <boris.brezillon@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/15816>

13 files changed, 141 insertions, 132 deletions

diff --git a/src/microsoft/vulkan/dzn_cmd_buffer.cpp b/src/microsoft/vulkan/dzn_cmd_buffer.c
index 495b0468f7e..d5172c38a45 100644
--- a/src/microsoft/vulkan/dzn_cmd_buffer.cpp
+++ b/src/microsoft/vulkan/dzn_cmd_buffer.c
@@ -182,16 +182,16 @@ dzn_cmd_buffer_create(const VkCommandBufferAllocateInfo *info,
    cmdbuf->vk.destroy = dzn_cmd_buffer_destroy;
 
    if (FAILED(ID3D12Device1_CreateCommandAllocator(device->dev, type,
-                                                   IID_ID3D12CommandAllocator,
-                                                   (void **)&cmdbuf->cmdalloc))) {
+                                                   &IID_ID3D12CommandAllocator,
+                                                   &cmdbuf->cmdalloc))) {
       result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
 
    if (FAILED(ID3D12Device1_CreateCommandList(device->dev, 0, type,
                                               cmdbuf->cmdalloc, NULL,
-                                              IID_ID3D12GraphicsCommandList1,
-                                              (void **)&cmdbuf->cmdlist))) {
+                                              &IID_ID3D12GraphicsCommandList1,
+                                              &cmdbuf->cmdlist))) {
       result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
@@ -265,8 +265,8 @@ dzn_cmd_buffer_reset(struct dzn_cmd_buffer *cmdbuf)
    if (FAILED(ID3D12Device1_CreateCommandList(device->dev, 0,
                                               type,
                                               cmdbuf->cmdalloc, NULL,
-                                              IID_ID3D12GraphicsCommandList1,
-                                              (void **)&cmdbuf->cmdlist))) {
+                                              &IID_ID3D12GraphicsCommandList1,
+                                              &cmdbuf->cmdlist))) {
       cmdbuf->error = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
 
@@ -689,7 +689,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
     * D3D12 barrier API.
     */
    if (info->memoryBarrierCount) {
-      D3D12_RESOURCE_BARRIER barriers[2] = {};
+      D3D12_RESOURCE_BARRIER barriers[2] = { 0 };
 
       barriers[0].Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
       barriers[0].Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
@@ -703,7 +703,7 @@ dzn_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
 
    for (uint32_t i = 0; i < info->bufferMemoryBarrierCount; i++) {
       VK_FROM_HANDLE(dzn_buffer, buf, info->pBufferMemoryBarriers[i].buffer);
-      D3D12_RESOURCE_BARRIER barrier = {};
+      D3D12_RESOURCE_BARRIER barrier = { 0 };
 
       /* UAV are used only for storage buffers, skip all other buffers. */
       if (!(buf->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT))
@@ -863,8 +863,8 @@ dzn_cmd_buffer_alloc_internal_buf(struct dzn_cmd_buffer *cmdbuf,
       ID3D12Device1_CreateCommittedResource(device->dev, &hprops,
                                             D3D12_HEAP_FLAG_NONE, &rdesc,
                                             init_state, NULL,
-                                            IID_ID3D12Resource,
-                                            (void **)&res);
+                                            &IID_ID3D12Resource,
+                                            &res);
    if (FAILED(hres)) {
       cmdbuf->error = vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
       return cmdbuf->error;
@@ -895,8 +895,8 @@ dzn_cmd_buffer_clear_rects_with_copy(struct dzn_cmd_buffer *cmdbuf,
 {
    enum pipe_format pfmt = vk_format_to_pipe_format(image->vk.format);
    uint32_t blksize = util_format_get_blocksize(pfmt);
-   uint8_t buf[D3D12_TEXTURE_DATA_PITCH_ALIGNMENT * 3] = {};
-   uint32_t raw[4] = {};
+   uint8_t buf[D3D12_TEXTURE_DATA_PITCH_ALIGNMENT * 3] = { 0 };
+   uint32_t raw[4] = { 0 };
 
    assert(blksize <= sizeof(raw));
    assert(!(sizeof(buf) % blksize));
@@ -1046,8 +1046,8 @@ dzn_cmd_buffer_clear_ranges_with_copy(struct dzn_cmd_buffer *cmdbuf,
 {
    enum pipe_format pfmt = vk_format_to_pipe_format(image->vk.format);
    uint32_t blksize = util_format_get_blocksize(pfmt);
-   uint8_t buf[D3D12_TEXTURE_DATA_PITCH_ALIGNMENT * 3] = {};
-   uint32_t raw[4] = {};
+   uint8_t buf[D3D12_TEXTURE_DATA_PITCH_ALIGNMENT * 3] = { 0 };
+   uint32_t raw[4] = { 0 };
 
    assert(blksize <= sizeof(raw));
    assert(!(sizeof(buf) % blksize));
@@ -1376,7 +1376,7 @@ dzn_cmd_buffer_clear_zs(struct dzn_cmd_buffer *cmdbuf,
 
          dzn_foreach_aspect(aspect, range->aspectMask) {
             barrier_aspects[barrier_count] = aspect;
-            barriers[barrier_count] = D3D12_RESOURCE_BARRIER {
+            barriers[barrier_count] = (D3D12_RESOURCE_BARRIER) {
                .Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
                .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,
                .Transition = {
@@ -2238,7 +2238,7 @@ dzn_cmd_buffer_resolve_attachment(struct dzn_cmd_buffer *cmdbuf, uint32_t i)
 
    /* TODO: 2DArrays/3D */
    if (subpass->colors[i].during != D3D12_RESOURCE_STATE_RESOLVE_SOURCE) {
-      barriers[barrier_count++] = D3D12_RESOURCE_BARRIER {
+      barriers[barrier_count++] = (D3D12_RESOURCE_BARRIER) {
          .Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
          .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,
          .Transition = {
@@ -2251,7 +2251,7 @@ dzn_cmd_buffer_resolve_attachment(struct dzn_cmd_buffer *cmdbuf, uint32_t i)
    }
 
    if (subpass->resolve[i].during != D3D12_RESOURCE_STATE_RESOLVE_DEST) {
-      barriers[barrier_count++] = D3D12_RESOURCE_BARRIER {
+      barriers[barrier_count++] = (D3D12_RESOURCE_BARRIER) {
          .Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
          .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,
          .Transition = {
@@ -2284,7 +2284,7 @@ dzn_cmd_buffer_begin_subpass(struct dzn_cmd_buffer *cmdbuf)
    struct dzn_render_pass *pass = cmdbuf->state.pass;
    const struct dzn_subpass *subpass = &pass->subpasses[cmdbuf->state.subpass];
 
-   D3D12_CPU_DESCRIPTOR_HANDLE rt_handles[MAX_RTS] = { };
+   D3D12_CPU_DESCRIPTOR_HANDLE rt_handles[MAX_RTS] = { 0 };
    D3D12_CPU_DESCRIPTOR_HANDLE zs_handle = { 0 };
 
    for (uint32_t i = 0; i < subpass->color_count; i++) {
@@ -2360,8 +2360,8 @@ dzn_cmd_buffer_update_heaps(struct dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
       desc_state->heaps[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV],
       desc_state->heaps[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER]
    };
-   uint32_t new_heap_offsets[NUM_POOL_TYPES] = {};
-   bool update_root_desc_table[NUM_POOL_TYPES] = {};
+   uint32_t new_heap_offsets[NUM_POOL_TYPES] = { 0 };
+   bool update_root_desc_table[NUM_POOL_TYPES] = { 0 };
    const struct dzn_pipeline *pipeline =
       cmdbuf->state.bindpoint[bindpoint].pipeline;
 
@@ -2901,7 +2901,7 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
 
    ID3D12GraphicsCommandList1_ResourceBarrier(cmdbuf->cmdlist, post_barrier_count, post_barriers);
 
-   D3D12_INDEX_BUFFER_VIEW ib_view = {};
+   D3D12_INDEX_BUFFER_VIEW ib_view = { 0 };
 
    if (triangle_fan_exec_buf) {
       enum dzn_index_type index_type =
@@ -2911,7 +2911,7 @@ dzn_cmd_buffer_indirect_draw(struct dzn_cmd_buffer *cmdbuf,
       struct dzn_meta_triangle_fan_rewrite_index *rewrite_index =
          &device->triangle_fan[index_type];
 
-      struct dzn_triangle_fan_rewrite_index_params rewrite_index_params = {};
+      struct dzn_triangle_fan_rewrite_index_params rewrite_index_params = { 0 };
 
       assert(rewrite_index->root_sig);
       assert(rewrite_index->pipeline_state);
@@ -3106,7 +3106,7 @@ dzn_CmdCopyImage2(VkCommandBuffer commandBuffer,
       };
 
       for (uint32_t r = 0; r < info->regionCount; r++) {
-         blit_regions[r] = VkImageBlit2 {
+         blit_regions[r] = (VkImageBlit2) {
             .sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
             .srcSubresource = info->pRegions[r].srcSubresource,
             .srcOffsets = {
@@ -3134,7 +3134,7 @@ dzn_CmdCopyImage2(VkCommandBuffer commandBuffer,
       return;
    }
 
-   D3D12_TEXTURE_COPY_LOCATION tmp_loc = {};
+   D3D12_TEXTURE_COPY_LOCATION tmp_loc = { 0 };
    D3D12_RESOURCE_DESC tmp_desc = {
       .Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
       .Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
@@ -3428,7 +3428,7 @@ dzn_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
    assert(pass->attachment_count == framebuffer->attachment_count);
 
    cmdbuf->state.framebuffer = framebuffer;
-   cmdbuf->state.render_area = D3D12_RECT {
+   cmdbuf->state.render_area = (D3D12_RECT) {
       .left = pRenderPassBeginInfo->renderArea.offset.x,
       .top = pRenderPassBeginInfo->renderArea.offset.y,
       .right = (LONG)(pRenderPassBeginInfo->renderArea.offset.x + pRenderPassBeginInfo->renderArea.extent.width),
diff --git a/src/microsoft/vulkan/dzn_descriptor_set.cpp b/src/microsoft/vulkan/dzn_descriptor_set.c
index d15b618e3e3..b19da113a33 100644
--- a/src/microsoft/vulkan/dzn_descriptor_set.cpp
+++ b/src/microsoft/vulkan/dzn_descriptor_set.c
@@ -131,7 +131,7 @@ dzn_descriptor_set_layout_create(struct dzn_device *device,
    const VkDescriptorSetLayoutBinding *bindings = pCreateInfo->pBindings;
    uint32_t binding_count = 0, static_sampler_count = 0, total_ranges = 0;
    uint32_t dynamic_ranges_offset = 0, immutable_sampler_count = 0;
-   uint32_t range_count[MAX_SHADER_VISIBILITIES][NUM_POOL_TYPES] = {};
+   uint32_t range_count[MAX_SHADER_VISIBILITIES][NUM_POOL_TYPES] = { 0 };
 
    for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
       binding_count = MAX2(binding_count, bindings[i].binding + 1);
@@ -246,7 +246,7 @@ dzn_descriptor_set_layout_create(struct dzn_device *device,
           (pCreateInfo->bindingCount ?
            (ordered_bindings[pCreateInfo->bindingCount - 1].binding + 1) : 0));
 
-   uint32_t range_idx[MAX_SHADER_VISIBILITIES][NUM_POOL_TYPES] = {};
+   uint32_t range_idx[MAX_SHADER_VISIBILITIES][NUM_POOL_TYPES] = { 0 };
    uint32_t static_sampler_idx = 0, immutable_sampler_idx = 0;
    uint32_t dynamic_buffer_idx = 0;
    uint32_t base_register = 0;
@@ -333,7 +333,7 @@ dzn_descriptor_set_layout_create(struct dzn_device *device,
 
       assert(visibility < ARRAY_SIZE(set_layout->ranges));
 
-      bool has_range[NUM_POOL_TYPES] = {};
+      bool has_range[NUM_POOL_TYPES] = { 0 };
       has_range[D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER] =
          has_sampler && !has_static_sampler;
       has_range[D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV] =
@@ -585,7 +585,7 @@ dzn_pipeline_layout_create(struct dzn_device *device,
    }
 
 
-   D3D12_ROOT_PARAMETER1 root_params[MAX_ROOT_PARAMS] = {};
+   D3D12_ROOT_PARAMETER1 root_params[MAX_ROOT_PARAMS] = { 0 };
    D3D12_DESCRIPTOR_RANGE1 *range_ptr = ranges;
    D3D12_ROOT_PARAMETER1 *root_param;
    uint32_t root_dwords = 0;
@@ -788,8 +788,8 @@ dzn_descriptor_heap_init(struct dzn_descriptor_heap *heap,
    };
 
    if (FAILED(ID3D12Device1_CreateDescriptorHeap(device->dev, &desc,
-                                                 IID_ID3D12DescriptorHeap,
-                                                 (void **)&heap->heap))) {
+                                                 &IID_ID3D12DescriptorHeap,
+                                                 &heap->heap))) {
       return vk_error(device,
                       shader_visible ?
                       VK_ERROR_OUT_OF_DEVICE_MEMORY : VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -810,7 +810,7 @@ dzn_descriptor_heap_init(struct dzn_descriptor_heap *heap,
 D3D12_CPU_DESCRIPTOR_HANDLE
 dzn_descriptor_heap_get_cpu_handle(const struct dzn_descriptor_heap *heap, uint32_t desc_offset)
 {
-   return D3D12_CPU_DESCRIPTOR_HANDLE {
+   return (D3D12_CPU_DESCRIPTOR_HANDLE) {
       .ptr = heap->cpu_base + (desc_offset * heap->desc_sz),
    };
 }
@@ -818,7 +818,7 @@ dzn_descriptor_heap_get_cpu_handle(const struct dzn_descriptor_heap *heap, uint3
 D3D12_GPU_DESCRIPTOR_HANDLE
 dzn_descriptor_heap_get_gpu_handle(const struct dzn_descriptor_heap *heap, uint32_t desc_offset)
 {
-   return D3D12_GPU_DESCRIPTOR_HANDLE {
+   return (D3D12_GPU_DESCRIPTOR_HANDLE) {
       .ptr = heap->gpu_base ? heap->gpu_base + (desc_offset * heap->desc_sz) : 0,
    };
 }
diff --git a/src/microsoft/vulkan/dzn_device.cpp b/src/microsoft/vulkan/dzn_device.c
index f18413dcf0e..480ae263f82 100644
--- a/src/microsoft/vulkan/dzn_device.cpp
+++ b/src/microsoft/vulkan/dzn_device.c
@@ -78,7 +78,7 @@ static const struct vk_instance_extension_table instance_extensions = {
 static void
 dzn_physical_device_get_extensions(struct dzn_physical_device *pdev)
 {
-   pdev->vk.supported_extensions = vk_device_extension_table {
+   pdev->vk.supported_extensions = (struct vk_device_extension_table) {
 #ifdef DZN_USE_WSI_PLATFORM
       .KHR_swapchain                         = true,
 #endif
@@ -293,7 +293,7 @@ dzn_physical_device_cache_caps(struct dzn_physical_device *pdev)
    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++] = {
+   pdev->queue_families[pdev->queue_family_count++] = (struct dzn_queue_family) {
       .props = {
          .queueFlags = VK_QUEUE_GRAPHICS_BIT |
                        VK_QUEUE_COMPUTE_BIT |
@@ -307,7 +307,7 @@ dzn_physical_device_cache_caps(struct dzn_physical_device *pdev)
       },
    };
 
-   pdev->queue_families[pdev->queue_family_count++] = {
+   pdev->queue_families[pdev->queue_family_count++] = (struct dzn_queue_family) {
       .props = {
          .queueFlags = VK_QUEUE_COMPUTE_BIT |
                        VK_QUEUE_TRANSFER_BIT,
@@ -320,7 +320,7 @@ dzn_physical_device_cache_caps(struct dzn_physical_device *pdev)
       },
    };
 
-   pdev->queue_families[pdev->queue_family_count++] = {
+   pdev->queue_families[pdev->queue_family_count++] = (struct dzn_queue_family) {
       .props = {
          .queueFlags = VK_QUEUE_TRANSFER_BIT,
          .queueCount = 1,
@@ -343,8 +343,8 @@ dzn_physical_device_cache_caps(struct dzn_physical_device *pdev)
 
    ID3D12CommandQueue *cmdqueue;
    ID3D12Device1_CreateCommandQueue(pdev->dev, &queue_desc,
-                                    IID_ID3D12CommandQueue,
-                                    (void **)&cmdqueue);
+                                    &IID_ID3D12CommandQueue,
+                                    &cmdqueue);
 
    uint64_t ts_freq;
    ID3D12CommandQueue_GetTimestampFrequency(cmdqueue, &ts_freq);
@@ -359,17 +359,17 @@ dzn_physical_device_init_memory(struct dzn_physical_device *pdev)
    const DXGI_ADAPTER_DESC1 *desc = &pdev->adapter_desc;
 
    mem->memoryHeapCount = 1;
-   mem->memoryHeaps[0] = VkMemoryHeap {
+   mem->memoryHeaps[0] = (VkMemoryHeap) {
       .size = desc->SharedSystemMemory,
       .flags = 0,
    };
 
-   mem->memoryTypes[mem->memoryTypeCount++] = VkMemoryType {
+   mem->memoryTypes[mem->memoryTypeCount++] = (VkMemoryType) {
       .propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
       .heapIndex = 0,
    };
-   mem->memoryTypes[mem->memoryTypeCount++] = VkMemoryType {
+   mem->memoryTypes[mem->memoryTypeCount++] = (VkMemoryType) {
       .propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                        VK_MEMORY_PROPERTY_HOST_CACHED_BIT |
                        VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
@@ -377,11 +377,11 @@ dzn_physical_device_init_memory(struct dzn_physical_device *pdev)
    };
 
    if (!pdev->architecture.UMA) {
-      mem->memoryHeaps[mem->memoryHeapCount++] = VkMemoryHeap {
+      mem->memoryHeaps[mem->memoryHeapCount++] = (VkMemoryHeap) {
          .size = desc->DedicatedVideoMemory,
          .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
       };
-      mem->memoryTypes[mem->memoryTypeCount++] = VkMemoryType {
+      mem->memoryTypes[mem->memoryTypeCount++] = (VkMemoryType) {
          .propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
          .heapIndex = mem->memoryHeapCount - 1,
       };
@@ -559,13 +559,13 @@ dzn_physical_device_get_format_properties(struct dzn_physical_device *pdev,
    }
 
    if (dfmt_info.Format == DXGI_FORMAT_UNKNOWN) {
-      *base_props = VkFormatProperties { };
+      *base_props = (VkFormatProperties) { 0 };
       return;
    }
 
    ID3D12Device1 *dev = dzn_physical_device_get_d3d12_dev(pdev);
 
-   *base_props = VkFormatProperties {
+   *base_props = (VkFormatProperties) {
       .linearTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
       .optimalTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
       .bufferFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
@@ -657,7 +657,7 @@ dzn_physical_device_get_image_format_properties(struct dzn_physical_device *pdev
    const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
    VkExternalImageFormatProperties *external_props = NULL;
 
-   *properties = VkImageFormatProperties2 {
+   *properties = (VkImageFormatProperties2) {
       .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
    };
 
@@ -857,7 +857,7 @@ dzn_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
       .flags = createFlags,
    };
 
-   VkImageFormatProperties2 props = {};
+   VkImageFormatProperties2 props = { 0 };
 
    VkResult result =
       dzn_GetPhysicalDeviceImageFormatProperties2(physicalDevice, &info, &props);
@@ -894,7 +894,7 @@ dzn_GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,
                                               VkExternalBufferProperties *pExternalBufferProperties)
 {
    pExternalBufferProperties->externalMemoryProperties =
-      VkExternalMemoryProperties {
+      (VkExternalMemoryProperties) {
          .compatibleHandleTypes = (VkExternalMemoryHandleTypeFlags)pExternalBufferInfo->handleType,
       };
 }
@@ -960,7 +960,7 @@ dzn_physical_device_supports_compressed_format(struct dzn_physical_device *pdev,
          VK_FORMAT_FEATURE_BLIT_SRC_BIT | \
          VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)
    for (uint32_t i = 0; i < format_count; i++) {
-      VkFormatProperties2 props = {};
+      VkFormatProperties2 props = { 0 };
       dzn_physical_device_get_format_properties(pdev, formats[i], &props);
       if ((props.formatProperties.optimalTilingFeatures & REQUIRED_COMPRESSED_CAPS) != REQUIRED_COMPRESSED_CAPS)
          return false;
@@ -1000,7 +1000,7 @@ dzn_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
 {
    VK_FROM_HANDLE(dzn_physical_device, pdev, physicalDevice);
 
-   pFeatures->features = VkPhysicalDeviceFeatures {
+   pFeatures->features = (VkPhysicalDeviceFeatures) {
       .robustBufferAccess = true, /* This feature is mandatory */
       .fullDrawIndexUint32 = false,
       .imageCubeArray = true,
@@ -1296,7 +1296,7 @@ dzn_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
       devtype = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
    }
 
-   pProperties->properties = VkPhysicalDeviceProperties {
+   pProperties->properties = (VkPhysicalDeviceProperties) {
       .apiVersion = DZN_API_VERSION,
       .driverVersion = vk_get_driver_version(),
 
@@ -1548,15 +1548,15 @@ dzn_queue_init(struct dzn_queue *queue,
    queue_desc.NodeMask = 0;
 
    if (FAILED(ID3D12Device1_CreateCommandQueue(device->dev, &queue_desc,
-                                               IID_ID3D12CommandQueue,
-                                               (void **)&queue->cmdqueue))) {
+                                               &IID_ID3D12CommandQueue,
+                                               &queue->cmdqueue))) {
       dzn_queue_finish(queue);
       return vk_error(device->vk.physical->instance, VK_ERROR_INITIALIZATION_FAILED);
    }
 
    if (FAILED(ID3D12Device1_CreateFence(device->dev, 0, D3D12_FENCE_FLAG_NONE,
-                                        IID_ID3D12Fence,
-                                        (void **)&queue->fence))) {
+                                        &IID_ID3D12Fence,
+                                        &queue->fence))) {
       dzn_queue_finish(queue);
       return vk_error(device->vk.physical->instance, VK_ERROR_INITIALIZATION_FAILED);
    }
@@ -1635,12 +1635,12 @@ dzn_device_query_init(struct dzn_device *device)
                                                    &rdesc,
                                                    D3D12_RESOURCE_STATE_GENERIC_READ,
                                                    NULL,
-                                                   IID_ID3D12Resource,
-                                                   (void **)&device->queries.refs)))
+                                                   &IID_ID3D12Resource,
+                                                   &device->queries.refs)))
       return vk_error(device->vk.physical, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    uint8_t *queries_ref;
-   if (FAILED(ID3D12Resource_Map(device->queries.refs, 0, NULL, (void **)&queries_ref)))
+   if (FAILED(ID3D12Resource_Map(device->queries.refs, 0, NULL, &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);
@@ -1748,8 +1748,9 @@ dzn_device_create(struct dzn_physical_device *pdev,
    ID3D12Device1_AddRef(device->dev);
 
    ID3D12InfoQueue *info_queue;
-   if (SUCCEEDED(ID3D12Device1_QueryInterface(device->dev, IID_ID3D12InfoQueue,
-                                              (void **)&info_queue))) {
+   if (SUCCEEDED(ID3D12Device1_QueryInterface(device->dev,
+                                              &IID_ID3D12InfoQueue,
+                                              &info_queue))) {
       D3D12_MESSAGE_SEVERITY severities[] = {
          D3D12_MESSAGE_SEVERITY_INFO,
          D3D12_MESSAGE_SEVERITY_WARNING,
@@ -1759,7 +1760,7 @@ dzn_device_create(struct dzn_physical_device *pdev,
          D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE,
       };
 
-      D3D12_INFO_QUEUE_FILTER NewFilter = {};
+      D3D12_INFO_QUEUE_FILTER NewFilter = { 0 };
       NewFilter.DenyList.NumSeverities = ARRAY_SIZE(severities);
       NewFilter.DenyList.pSeverityList = severities;
       NewFilter.DenyList.NumIDs = ARRAY_SIZE(msg_ids);
@@ -1826,8 +1827,8 @@ dzn_device_create_root_sig(struct dzn_device *device,
    if (FAILED(ID3D12Device1_CreateRootSignature(device->dev, 0,
                                                 ID3D10Blob_GetBufferPointer(sig),
                                                 ID3D10Blob_GetBufferSize(sig),
-                                                IID_ID3D12RootSignature,
-                                                (void **)&root_sig))) {
+                                                &IID_ID3D12RootSignature,
+                                                &root_sig))) {
       ID3D10Blob_Release(sig);
       return NULL;
    }
@@ -1936,7 +1937,7 @@ dzn_device_memory_create(struct dzn_device *device,
    const VkMemoryType *mem_type =
       &pdevice->memory.memoryTypes[pAllocateInfo->memoryTypeIndex];
 
-   D3D12_HEAP_DESC heap_desc = {};
+   D3D12_HEAP_DESC heap_desc = { 0 };
    // TODO: fix all of these:
    heap_desc.SizeInBytes = pAllocateInfo->allocationSize;
    heap_desc.Alignment =
@@ -1963,15 +1964,15 @@ dzn_device_memory_create(struct dzn_device *device,
    }
 
    if (FAILED(ID3D12Device1_CreateHeap(device->dev, &heap_desc,
-                                       IID_ID3D12Heap,
-                                       (void **)&mem->heap))) {
+                                       &IID_ID3D12Heap,
+                                       &mem->heap))) {
       dzn_device_memory_destroy(mem, pAllocator);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
    }
 
    if ((mem_type->propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) &&
        !(heap_desc.Flags & D3D12_HEAP_FLAG_DENY_BUFFERS)){
-      D3D12_RESOURCE_DESC res_desc = {};
+      D3D12_RESOURCE_DESC res_desc = { 0 };
       res_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
       res_desc.Format = DXGI_FORMAT_UNKNOWN;
       res_desc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
@@ -1986,8 +1987,8 @@ dzn_device_memory_create(struct dzn_device *device,
       HRESULT hr = ID3D12Device1_CreatePlacedResource(device->dev, mem->heap, 0, &res_desc,
                                                       mem->initial_state,
                                                       NULL,
-                                                      IID_ID3D12Resource,
-                                                      (void **)&mem->map_res);
+                                                      &IID_ID3D12Resource,
+                                                      &mem->map_res);
       if (FAILED(hr)) {
          dzn_device_memory_destroy(mem, pAllocator);
          return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@@ -2046,7 +2047,7 @@ dzn_MapMemory(VkDevice _device,
    assert(offset + size <= mem->size);
 
    assert(mem->map_res);
-   D3D12_RANGE range = {};
+   D3D12_RANGE range = { 0 };
    range.Begin = offset;
    range.End = offset + size;
    void *map = NULL;
@@ -2339,8 +2340,8 @@ dzn_BindBufferMemory2(VkDevice _device,
                                                    &buffer->desc,
                                                    mem->initial_state,
                                                    NULL,
-                                                   IID_ID3D12Resource,
-                                                   (void **)&buffer->res)))
+                                                   &IID_ID3D12Resource,
+                                                   &buffer->res)))
          return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
 
@@ -2441,8 +2442,8 @@ dzn_event_create(struct dzn_device *device,
    vk_object_base_init(&device->vk, &event->base, VK_OBJECT_TYPE_EVENT);
 
    if (FAILED(ID3D12Device1_CreateFence(device->dev, 0, D3D12_FENCE_FLAG_NONE,
-                                        IID_ID3D12Fence,
-                                        (void **)&event->fence))) {
+                                        &IID_ID3D12Fence,
+                                        &event->fence))) {
       dzn_event_destroy(event, pAllocator);
       return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
    }
diff --git a/src/microsoft/vulkan/dzn_image.cpp b/src/microsoft/vulkan/dzn_image.c
index 48f923ca579..2d01dfdecaf 100644
--- a/src/microsoft/vulkan/dzn_image.cpp
+++ b/src/microsoft/vulkan/dzn_image.c
@@ -635,8 +635,8 @@ dzn_BindImageMemory2(VkDevice dev,
                                                       &image->desc,
                                                       mem->initial_state,
                                                       NULL,
-                                                      IID_ID3D12Resource,
-                                                      (void **)&image->res)))
+                                                      &IID_ID3D12Resource,
+                                                      &image->res)))
             return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
          did_bind = true;
       }
@@ -679,7 +679,7 @@ dzn_GetImageMemoryRequirements2(VkDevice _device,
    D3D12_RESOURCE_ALLOCATION_INFO info;
    ID3D12Device1_GetResourceAllocationInfo(device->dev, &info, 0, 1, &image->desc);
 
-   pMemoryRequirements->memoryRequirements = VkMemoryRequirements {
+   pMemoryRequirements->memoryRequirements = (VkMemoryRequirements) {
       .size = info.SizeInBytes,
       .alignment = info.Alignment,
       .memoryTypeBits =
@@ -773,7 +773,7 @@ dzn_image_view_prepare_srv_desc(struct dzn_image_view *iview)
    bool use_array = (iview->vk.base_array_layer / layers_per_elem) > 0 ||
                     (iview->vk.layer_count / layers_per_elem) > 1;
 
-   iview->srv_desc = D3D12_SHADER_RESOURCE_VIEW_DESC {
+   iview->srv_desc = (D3D12_SHADER_RESOURCE_VIEW_DESC) {
       .Format =
          dzn_image_get_dxgi_format(iview->vk.format,
                                    iview->vk.image->usage & ~VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
@@ -876,7 +876,7 @@ dzn_image_view_prepare_uav_desc(struct dzn_image_view *iview)
 
    assert(iview->vk.image->samples == 1);
 
-   iview->uav_desc = D3D12_UNORDERED_ACCESS_VIEW_DESC {
+   iview->uav_desc = (D3D12_UNORDERED_ACCESS_VIEW_DESC) {
       .Format =
          dzn_image_get_dxgi_format(iview->vk.format,
                                    VK_IMAGE_USAGE_STORAGE_BIT,
@@ -935,7 +935,7 @@ dzn_image_view_prepare_rtv_desc(struct dzn_image_view *iview)
 
    assert(iview->vk.level_count == 1);
 
-   iview->rtv_desc = D3D12_RENDER_TARGET_VIEW_DESC {
+   iview->rtv_desc = (D3D12_RENDER_TARGET_VIEW_DESC) {
       .Format =
          dzn_image_get_dxgi_format(iview->vk.format,
                                    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
@@ -1001,7 +1001,7 @@ dzn_image_view_prepare_dsv_desc(struct dzn_image_view *iview)
    bool use_array = iview->vk.base_array_layer > 0 || iview->vk.layer_count > 1;
    bool ms = iview->vk.image->samples > 1;
 
-   iview->dsv_desc = D3D12_DEPTH_STENCIL_VIEW_DESC {
+   iview->dsv_desc = (D3D12_DEPTH_STENCIL_VIEW_DESC) {
       .Format =
          dzn_image_get_dxgi_format(iview->vk.format,
                                    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
@@ -1192,7 +1192,7 @@ dzn_buffer_view_create(struct dzn_device *device,
    if (buf->usage &
        (VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
         VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) {
-      bview->srv_desc = D3D12_SHADER_RESOURCE_VIEW_DESC {
+      bview->srv_desc = (D3D12_SHADER_RESOURCE_VIEW_DESC) {
          .Format = dzn_buffer_get_dxgi_format(pCreateInfo->format),
          .ViewDimension = D3D12_SRV_DIMENSION_BUFFER,
          .Shader4ComponentMapping =
@@ -1206,7 +1206,7 @@ dzn_buffer_view_create(struct dzn_device *device,
    }
 
    if (buf->usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
-      bview->uav_desc = D3D12_UNORDERED_ACCESS_VIEW_DESC {
+      bview->uav_desc = (D3D12_UNORDERED_ACCESS_VIEW_DESC) {
          .Format = dzn_buffer_get_dxgi_format(pCreateInfo->format),
          .ViewDimension = D3D12_UAV_DIMENSION_BUFFER,
          .Buffer = {
diff --git a/src/microsoft/vulkan/dzn_meta.cpp b/src/microsoft/vulkan/dzn_meta.c
index ebd0108ddb0..ce69cce8703 100644
--- a/src/microsoft/vulkan/dzn_meta.cpp
+++ b/src/microsoft/vulkan/dzn_meta.c
@@ -123,7 +123,7 @@ dzn_meta_indirect_draw_init(struct dzn_device *device,
    uint32_t root_param_count = 0;
    D3D12_ROOT_PARAMETER1 root_params[DZN_META_INDIRECT_DRAW_MAX_PARAM_COUNT];
 
-   root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+   root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
       .ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS,
       .Constants = {
          .ShaderRegister = 0,
@@ -133,7 +133,7 @@ dzn_meta_indirect_draw_init(struct dzn_device *device,
       .ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
    };
 
-   root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+   root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
       .ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV,
       .Descriptor = {
          .ShaderRegister = 1,
@@ -143,7 +143,7 @@ dzn_meta_indirect_draw_init(struct dzn_device *device,
       .ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
    };
 
-   root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+   root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
       .ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV,
       .Descriptor = {
          .ShaderRegister = 2,
@@ -155,7 +155,7 @@ dzn_meta_indirect_draw_init(struct dzn_device *device,
 
 
    if (triangle_fan) {
-      root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+      root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
          .ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV,
          .Descriptor = {
             .ShaderRegister = 3,
@@ -193,8 +193,8 @@ dzn_meta_indirect_draw_init(struct dzn_device *device,
    assert(desc.CS.pShaderBytecode);
 
    if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
-                                                       IID_ID3D12PipelineState,
-                                                       (void **)&meta->pipeline_state)))
+                                                       &IID_ID3D12PipelineState,
+                                                       &meta->pipeline_state)))
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
 
 out:
@@ -244,7 +244,7 @@ dzn_meta_triangle_fan_rewrite_index_init(struct dzn_device *device,
    uint32_t root_param_count = 0;
    D3D12_ROOT_PARAMETER1 root_params[DZN_META_TRIANGLE_FAN_REWRITE_IDX_MAX_PARAM_COUNT];
 
-   root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+   root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
       .ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV,
       .Descriptor = {
          .ShaderRegister = 1,
@@ -254,7 +254,7 @@ dzn_meta_triangle_fan_rewrite_index_init(struct dzn_device *device,
       .ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL,
    };
 
-   root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+   root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
       .ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS,
       .Constants = {
          .ShaderRegister = 0,
@@ -265,7 +265,7 @@ dzn_meta_triangle_fan_rewrite_index_init(struct dzn_device *device,
    };
 
    if (old_index_type != DZN_NO_INDEX) {
-      root_params[root_param_count++] = D3D12_ROOT_PARAMETER1 {
+      root_params[root_param_count++] = (D3D12_ROOT_PARAMETER1) {
          .ParameterType = D3D12_ROOT_PARAMETER_TYPE_SRV,
          .Descriptor = {
             .ShaderRegister = 2,
@@ -330,16 +330,16 @@ dzn_meta_triangle_fan_rewrite_index_init(struct dzn_device *device,
    dzn_meta_compile_shader(device, nir, &desc.CS);
 
    if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
-                                                       IID_ID3D12PipelineState,
-                                                       (void **)&meta->pipeline_state))) {
+                                                       &IID_ID3D12PipelineState,
+                                                       &meta->pipeline_state))) {
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
       goto out;
    }
 
    if (FAILED(ID3D12Device1_CreateCommandSignature(device->dev, &cmd_sig_desc,
                                                    meta->root_sig,
-                                                   IID_ID3D12CommandSignature,
-                                                   (void **)&meta->cmd_sig)))
+                                                   &IID_ID3D12CommandSignature,
+                                                   &meta->cmd_sig)))
       ret = vk_error(instance, VK_ERROR_INITIALIZATION_FAILED);
 
 out:
@@ -612,8 +612,8 @@ dzn_meta_blit_create(struct dzn_device *device, const struct dzn_meta_blit_key *
    }
 
    if (FAILED(ID3D12Device1_CreateGraphicsPipelineState(device->dev, &desc,
-                                                        IID_ID3D12PipelineState,
-                                                        (void **)&blit->pipeline_state))) {
+                                                        &IID_ID3D12PipelineState,
+                                                        &blit->pipeline_state))) {
       dzn_meta_blit_destroy(device, blit);
       return NULL;
    }
diff --git a/src/microsoft/vulkan/dzn_pass.cpp b/src/microsoft/vulkan/dzn_pass.c
index 67e0e0c5608..67e0e0c5608 100644
--- a/src/microsoft/vulkan/dzn_pass.cpp
+++ b/src/microsoft/vulkan/dzn_pass.c
diff --git a/src/microsoft/vulkan/dzn_pipeline.cpp b/src/microsoft/vulkan/dzn_pipeline.c
index c0726c5c6af..11fd1a54b75 100644
--- a/src/microsoft/vulkan/dzn_pipeline.cpp
+++ b/src/microsoft/vulkan/dzn_pipeline.c
@@ -905,8 +905,8 @@ dzn_graphics_pipeline_create(struct dzn_device *device,
 
 
    hres = ID3D12Device1_CreateGraphicsPipelineState(device->dev, &desc,
-                                                    IID_ID3D12PipelineState,
-                                                    (void **)&pipeline->base.state);
+                                                    &IID_ID3D12PipelineState,
+                                                    &pipeline->base.state);
    if (FAILED(hres)) {
       ret = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
@@ -952,12 +952,12 @@ dzn_graphics_pipeline_get_indirect_cmd_sig(struct dzn_graphics_pipeline *pipelin
    D3D12_INDIRECT_ARGUMENT_DESC cmd_args[DZN_INDIRECT_CMD_SIG_MAX_ARGS];
 
    if (triangle_fan) {
-      cmd_args[cmd_arg_count++] = D3D12_INDIRECT_ARGUMENT_DESC {
+      cmd_args[cmd_arg_count++] = (D3D12_INDIRECT_ARGUMENT_DESC) {
          .Type = D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW,
       };
    }
 
-   cmd_args[cmd_arg_count++] = D3D12_INDIRECT_ARGUMENT_DESC {
+   cmd_args[cmd_arg_count++] = (D3D12_INDIRECT_ARGUMENT_DESC) {
       .Type = D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT,
       .Constant = {
          .RootParameterIndex = pipeline->base.root.sysval_cbv_param_idx,
@@ -966,7 +966,7 @@ dzn_graphics_pipeline_get_indirect_cmd_sig(struct dzn_graphics_pipeline *pipelin
       },
    };
 
-   cmd_args[cmd_arg_count++] = D3D12_INDIRECT_ARGUMENT_DESC {
+   cmd_args[cmd_arg_count++] = (D3D12_INDIRECT_ARGUMENT_DESC) {
       .Type = indexed ?
               D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED :
               D3D12_INDIRECT_ARGUMENT_TYPE_DRAW,
@@ -986,8 +986,8 @@ dzn_graphics_pipeline_get_indirect_cmd_sig(struct dzn_graphics_pipeline *pipelin
    HRESULT hres =
       ID3D12Device1_CreateCommandSignature(device->dev, &cmd_sig_desc,
                                            pipeline->base.root.sig,
-                                           IID_ID3D12CommandSignature,
-                                           (void **)&cmdsig);
+                                           &IID_ID3D12CommandSignature,
+                                           &cmdsig);
    if (FAILED(hres))
       return NULL;
 
@@ -1080,8 +1080,8 @@ dzn_compute_pipeline_create(struct dzn_device *device,
       goto out;
 
    if (FAILED(ID3D12Device1_CreateComputePipelineState(device->dev, &desc,
-                                                       IID_ID3D12PipelineState,
-                                                       (void **)&pipeline->base.state))) {
+                                                       &IID_ID3D12PipelineState,
+                                                       &pipeline->base.state))) {
       ret = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
       goto out;
    }
@@ -1128,8 +1128,8 @@ dzn_compute_pipeline_get_indirect_cmd_sig(struct dzn_compute_pipeline *pipeline)
    HRESULT hres =
       ID3D12Device1_CreateCommandSignature(device->dev, &indirect_dispatch_desc,
                                            pipeline->base.root.sig,
-                                           IID_ID3D12CommandSignature,
-                                           (void **)&pipeline->indirect_cmd_sig);
+                                           &IID_ID3D12CommandSignature,
+                                           &pipeline->indirect_cmd_sig);
    if (FAILED(hres))
       return NULL;
 
diff --git a/src/microsoft/vulkan/dzn_pipeline_cache.cpp b/src/microsoft/vulkan/dzn_pipeline_cache.c
index de6e3053c0a..de6e3053c0a 100644
--- a/src/microsoft/vulkan/dzn_pipeline_cache.cpp
+++ b/src/microsoft/vulkan/dzn_pipeline_cache.c
diff --git a/src/microsoft/vulkan/dzn_private.h b/src/microsoft/vulkan/dzn_private.h
index c4492843f59..0b08e517bdf 100644
--- a/src/microsoft/vulkan/dzn_private.h
+++ b/src/microsoft/vulkan/dzn_private.h
@@ -173,7 +173,7 @@ struct dzn_physical_device {
    DXGI_ADAPTER_DESC1 adapter_desc;
 
    uint32_t queue_family_count;
-   struct {
+   struct dzn_queue_family {
       VkQueueFamilyProperties props;
       D3D12_COMMAND_QUEUE_DESC desc;
    } queue_families[MAX_QUEUE_FAMILIES];
@@ -206,6 +206,10 @@ dzn_physical_device_get_mem_type_mask_for_resource(const struct dzn_physical_dev
 #define dzn_debug_ignored_stype(sType) \
    mesa_logd("%s: ignored VkStructureType %u\n", __func__, (sType))
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 IDXGIFactory4 *
 dxgi_get_factory(bool debug);
 
@@ -221,6 +225,10 @@ d3d12_enable_gpu_validation();
 ID3D12Device1 *
 d3d12_create_device(IDXGIAdapter1 *adapter, bool experimental_features);
 
+#ifdef __cplusplus
+}
+#endif
+
 struct dzn_queue {
    struct vk_queue vk;
 
diff --git a/src/microsoft/vulkan/dzn_query.cpp b/src/microsoft/vulkan/dzn_query.c
index 6d8712f05a0..0739e22091f 100644
--- a/src/microsoft/vulkan/dzn_query.cpp
+++ b/src/microsoft/vulkan/dzn_query.c
@@ -110,8 +110,8 @@ dzn_query_pool_create(struct dzn_device *device,
 
    HRESULT hres =
       ID3D12Device1_CreateQueryHeap(device->dev, &desc,
-                                    IID_ID3D12QueryHeap,
-                                    (void **)&qpool->heap);
+                                    &IID_ID3D12QueryHeap,
+                                    &qpool->heap);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@@ -150,8 +150,8 @@ dzn_query_pool_create(struct dzn_device *device,
                                                 &rdesc,
                                                 D3D12_RESOURCE_STATE_COPY_DEST,
                                                 NULL,
-                                                IID_ID3D12Resource,
-                                                (void **)&qpool->resolve_buffer);
+                                                &IID_ID3D12Resource,
+                                                &qpool->resolve_buffer);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
@@ -165,8 +165,8 @@ dzn_query_pool_create(struct dzn_device *device,
                                                 &rdesc,
                                                 D3D12_RESOURCE_STATE_COPY_DEST,
                                                 NULL,
-                                                IID_ID3D12Resource,
-                                                (void **)&qpool->collect_buffer);
+                                                &IID_ID3D12Resource,
+                                                &qpool->collect_buffer);
    if (FAILED(hres)) {
       dzn_query_pool_destroy(qpool, alloc);
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
diff --git a/src/microsoft/vulkan/dzn_sync.cpp b/src/microsoft/vulkan/dzn_sync.c
index 4251e497352..1379c332c4e 100644
--- a/src/microsoft/vulkan/dzn_sync.cpp
+++ b/src/microsoft/vulkan/dzn_sync.c
@@ -42,8 +42,8 @@ dzn_sync_init(struct vk_device *device,
 
    if (FAILED(ID3D12Device1_CreateFence(ddev->dev, initial_value,
                                         D3D12_FENCE_FLAG_NONE,
-                                        IID_ID3D12Fence,
-                                        (void **)&dsync->fence)))
+                                        &IID_ID3D12Fence,
+                                        &dsync->fence)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    return VK_SUCCESS;
@@ -109,8 +109,8 @@ dzn_sync_move(struct vk_device *device,
 
    if (FAILED(ID3D12Device1_CreateFence(ddev->dev, 0,
                                         D3D12_FENCE_FLAG_NONE,
-                                        IID_ID3D12Fence,
-                                        (void **)&new_fence)))
+                                        &IID_ID3D12Fence,
+                                        &new_fence)))
       return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
 
    ID3D12Fence_Release(ddst->fence);
diff --git a/src/microsoft/vulkan/dzn_wsi.cpp b/src/microsoft/vulkan/dzn_wsi.c
index 1cb95ef0a00..1cb95ef0a00 100644
--- a/src/microsoft/vulkan/dzn_wsi.cpp
+++ b/src/microsoft/vulkan/dzn_wsi.c
diff --git a/src/microsoft/vulkan/meson.build b/src/microsoft/vulkan/meson.build
index 2d8ce7a8092..ac35a87c3c7 100644
--- a/src/microsoft/vulkan/meson.build
+++ b/src/microsoft/vulkan/meson.build
@@ -31,20 +31,20 @@ dzn_entrypoints = custom_target(
 )
 
 libdzn_files = files(
-  'dzn_cmd_buffer.cpp',
-  'dzn_descriptor_set.cpp',
-  'dzn_device.cpp',
-  'dzn_image.cpp',
-  'dzn_meta.cpp',
+  'dzn_cmd_buffer.c',
+  'dzn_descriptor_set.c',
+  'dzn_device.c',
+  'dzn_image.c',
+  'dzn_meta.c',
   'dzn_nir.c',
-  'dzn_pass.cpp',
-  'dzn_pipeline_cache.cpp',
-  'dzn_pipeline.cpp',
-  'dzn_query.cpp',
-  'dzn_sync.cpp',
+  'dzn_pass.c',
+  'dzn_pipeline_cache.c',
+  'dzn_pipeline.c',
+  'dzn_query.c',
+  'dzn_sync.c',
   'dzn_util.cpp',
   'dzn_util.c',
-  'dzn_wsi.cpp',
+  'dzn_wsi.c',
 )
 
 dzn_deps = [