mirrors
/
vkd3d-proton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vkd3d: Remove vk_buffer/vk_image union from d3d12_resource. 

Use the unique_resource struct instead.

Signed-off-by: Philip Rebohle <philip.rebohle@tu-dortmund.de>
This commit is contained in:
Philip Rebohle 2021-02-04 19:38:11 +01:00 committed by Hans-Kristian Arntzen
parent 5a0a5ef44b
commit 833d7e207c
4 changed files with 72 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
libs/vkd3d/command.c
View File

@ -2311,7 +2311,7 @@ static void d3d12_command_list_discard_attachment_barrier(struct d3d12_command_l
barrier.newLayout = layout;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = resource->vk_image;
barrier.image = resource->res.vk_image;
barrier.subresourceRange = vk_subresource_range_from_layers(subresource);
VK_CALL(vkCmdPipelineBarrier(list->vk_command_buffer,
@ -2506,7 +2506,7 @@ static VkPipelineStageFlags vk_render_pass_barrier_from_view(const struct vkd3d_
vk_barrier->srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vk_barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vk_barrier->image = resource->vk_image;
vk_barrier->image = resource->res.vk_image;
vk_barrier->subresourceRange = vk_subresource_range_from_view(view);
return stages;
}
@ -4927,7 +4927,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyBufferRegion(d3d12_command_
buffer_copy.size = byte_count;
VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer,
src_resource->vk_buffer, dst_resource->vk_buffer, 1, &buffer_copy));
src_resource->res.vk_buffer, dst_resource->res.vk_buffer, 1, &buffer_copy));
}
static void vk_image_subresource_layers_from_d3d12(VkImageSubresourceLayers *subresource,
@ -5121,14 +5121,14 @@ static void d3d12_command_list_copy_image(struct d3d12_command_list *list,
* This is also an optimization, since we can avoid a potential decompress when entering TRANSFER_DST layout. */
vk_image_barriers[0].oldLayout = writes_full_subresource ? VK_IMAGE_LAYOUT_UNDEFINED : dst_resource->common_layout;
vk_image_barriers[0].newLayout = dst_layout;
vk_image_barriers[0].image = dst_resource->vk_image;
vk_image_barriers[0].image = dst_resource->res.vk_image;
vk_image_barriers[0].subresourceRange = vk_subresource_range_from_layers(&region->dstSubresource);
vk_image_barriers[1].srcAccessMask = 0;
vk_image_barriers[1].dstAccessMask = src_access;
vk_image_barriers[1].oldLayout = src_resource->common_layout;
vk_image_barriers[1].newLayout = src_layout;
vk_image_barriers[1].image = src_resource->vk_image;
vk_image_barriers[1].image = src_resource->res.vk_image;
vk_image_barriers[1].subresourceRange = vk_subresource_range_from_layers(&region->srcSubresource);
VK_CALL(vkCmdPipelineBarrier(list->vk_command_buffer,
@ -5139,8 +5139,8 @@ static void d3d12_command_list_copy_image(struct d3d12_command_list *list,
if (use_copy)
{
VK_CALL(vkCmdCopyImage(list->vk_command_buffer,
src_resource->vk_image, src_layout,
dst_resource->vk_image, dst_layout,
src_resource->res.vk_image, src_layout,
dst_resource->res.vk_image, dst_layout,
1, region));
}
else
@ -5168,7 +5168,7 @@ static void d3d12_command_list_copy_image(struct d3d12_command_list *list,
d3d12_command_list_invalidate_root_parameters(list, VK_PIPELINE_BIND_POINT_GRAPHICS, true);
memset(&dst_view_desc, 0, sizeof(dst_view_desc));
dst_view_desc.image = dst_resource->vk_image;
dst_view_desc.image = dst_resource->res.vk_image;
dst_view_desc.view_type = pipeline_key.view_type;
dst_view_desc.layout = dst_layout;
dst_view_desc.format = dst_format;
@ -5179,7 +5179,7 @@ static void d3d12_command_list_copy_image(struct d3d12_command_list *list,
dst_view_desc.allowed_swizzle = false;
memset(&src_view_desc, 0, sizeof(src_view_desc));
src_view_desc.image = src_resource->vk_image;
src_view_desc.image = src_resource->res.vk_image;
src_view_desc.view_type = pipeline_key.view_type;
src_view_desc.layout = src_layout;
src_view_desc.format = src_format;
@ -5392,16 +5392,16 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(d3d12_command
vk_layout = d3d12_resource_pick_layout(src_resource, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
d3d12_command_list_transition_image_layout(list, src_resource->vk_image,
d3d12_command_list_transition_image_layout(list, src_resource->res.vk_image,
&buffer_image_copy.imageSubresource, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, src_resource->common_layout, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_ACCESS_TRANSFER_READ_BIT, vk_layout);
VK_CALL(vkCmdCopyImageToBuffer(list->vk_command_buffer,
src_resource->vk_image, vk_layout,
dst_resource->vk_buffer, 1, &buffer_image_copy));
src_resource->res.vk_image, vk_layout,
dst_resource->res.vk_buffer, 1, &buffer_image_copy));
d3d12_command_list_transition_image_layout(list, src_resource->vk_image,
d3d12_command_list_transition_image_layout(list, src_resource->res.vk_image,
&buffer_image_copy.imageSubresource, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
vk_layout, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, src_resource->common_layout);
}
@ -5439,17 +5439,17 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTextureRegion(d3d12_command
d3d12_command_list_track_resource_usage(list, dst_resource, !writes_full_subresource);
d3d12_command_list_transition_image_layout(list, dst_resource->vk_image,
d3d12_command_list_transition_image_layout(list, dst_resource->res.vk_image,
&buffer_image_copy.imageSubresource, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, writes_full_subresource ? VK_IMAGE_LAYOUT_UNDEFINED : dst_resource->common_layout,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_ACCESS_TRANSFER_WRITE_BIT, vk_layout);
VK_CALL(vkCmdCopyBufferToImage(list->vk_command_buffer,
src_resource->vk_buffer, dst_resource->vk_image,
src_resource->res.vk_buffer, dst_resource->res.vk_image,
vk_layout, 1, &buffer_image_copy));
d3d12_command_list_transition_image_layout(list, dst_resource->vk_image,
d3d12_command_list_transition_image_layout(list, dst_resource->res.vk_image,
&buffer_image_copy.imageSubresource, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_ACCESS_TRANSFER_WRITE_BIT, vk_layout, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, dst_resource->common_layout);
@ -5520,7 +5520,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyResource(d3d12_command_list
vk_buffer_copy.dstOffset = dst_resource->heap_offset;
vk_buffer_copy.size = dst_resource->desc.Width;
VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer,
src_resource->vk_buffer, dst_resource->vk_buffer, 1, &vk_buffer_copy));
src_resource->res.vk_buffer, dst_resource->res.vk_buffer, 1, &vk_buffer_copy));
}
else
{
@ -5602,7 +5602,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(d3d12_command_list_if
vk_image_barrier.dstAccessMask = copy_to_buffer ? VK_ACCESS_TRANSFER_READ_BIT : VK_ACCESS_TRANSFER_WRITE_BIT;
vk_image_barrier.oldLayout = tiled_res->common_layout;
vk_image_barrier.newLayout = vk_image_layout;
vk_image_barrier.image = tiled_res->vk_image;
vk_image_barrier.image = tiled_res->res.vk_image;
/* The entire resource must be in the appropriate copy state */
vk_image_barrier.subresourceRange.aspectMask = tiled_res->format->vk_aspect_mask;
@ -5631,13 +5631,13 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(d3d12_command_list_if
if (copy_to_buffer)
{
VK_CALL(vkCmdCopyImageToBuffer(list->vk_command_buffer,
tiled_res->vk_image, vk_image_layout, linear_res->vk_buffer,
tiled_res->res.vk_image, vk_image_layout, linear_res->res.vk_buffer,
1, &buffer_image_copy));
}
else
{
VK_CALL(vkCmdCopyBufferToImage(list->vk_command_buffer,
linear_res->vk_buffer, tiled_res->vk_image, vk_image_layout,
linear_res->res.vk_buffer, tiled_res->res.vk_image, vk_image_layout,
1, &buffer_image_copy));
}
}
@ -5667,8 +5667,8 @@ static void STDMETHODCALLTYPE d3d12_command_list_CopyTiles(d3d12_command_list_if
}
VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer,
copy_to_buffer ? tiled_res->vk_buffer : linear_res->vk_buffer,
copy_to_buffer ? linear_res->vk_buffer : tiled_res->vk_buffer,
copy_to_buffer ? tiled_res->res.vk_buffer : linear_res->res.vk_buffer,
copy_to_buffer ? linear_res->res.vk_buffer : tiled_res->res.vk_buffer,
1, &buffer_copy));
}
}
@ -5754,22 +5754,22 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveSubresource(d3d12_comman
vk_image_barriers[0].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
vk_image_barriers[0].oldLayout = writes_full_subresource ? VK_IMAGE_LAYOUT_UNDEFINED : dst_resource->common_layout;
vk_image_barriers[0].newLayout = dst_layout;
vk_image_barriers[0].image = dst_resource->vk_image;
vk_image_barriers[0].image = dst_resource->res.vk_image;
vk_image_barriers[0].subresourceRange = vk_subresource_range_from_layers(&vk_image_resolve.dstSubresource);
vk_image_barriers[1].srcAccessMask = 0;
vk_image_barriers[1].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
vk_image_barriers[1].oldLayout = src_resource->common_layout;
vk_image_barriers[1].newLayout = src_layout;
vk_image_barriers[1].image = src_resource->vk_image;
vk_image_barriers[1].image = src_resource->res.vk_image;
vk_image_barriers[1].subresourceRange = vk_subresource_range_from_layers(&vk_image_resolve.srcSubresource);
VK_CALL(vkCmdPipelineBarrier(list->vk_command_buffer,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
0, 0, NULL, 0, NULL, ARRAY_SIZE(vk_image_barriers), vk_image_barriers));
VK_CALL(vkCmdResolveImage(list->vk_command_buffer, src_resource->vk_image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_resource->vk_image,
VK_CALL(vkCmdResolveImage(list->vk_command_buffer, src_resource->res.vk_image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_resource->res.vk_image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &vk_image_resolve));
vk_image_barriers[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
@ -5960,7 +5960,7 @@ static void vk_image_memory_barrier_for_after_aliasing_barrier(struct d3d12_devi
vk_barrier->newLayout = after->common_layout;
vk_barrier->srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vk_barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
vk_barrier->image = after->vk_image;
vk_barrier->image = after->res.vk_image;
vk_barrier->subresourceRange.aspectMask = after->format->vk_aspect_mask;
vk_barrier->subresourceRange.baseMipLevel = 0;
vk_barrier->subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
@ -6995,7 +6995,7 @@ static void d3d12_command_list_clear_uav(struct d3d12_command_list *list, const
write_set.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
write_set.pBufferInfo = &buffer_info;
/* resource heap offset is already in descriptor */
buffer_info.buffer = resource->vk_buffer;
buffer_info.buffer = resource->res.vk_buffer;
buffer_info.offset = args->u.buffer.offset;
buffer_info.range = args->u.buffer.range;
}
@ -7159,7 +7159,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(d3
struct vkd3d_texture_view_desc view_desc;
memset(&view_desc, 0, sizeof(view_desc));
view_desc.image = resource_impl->vk_image;
view_desc.image = resource_impl->res.vk_image;
view_desc.view_type = base_view->info.texture.vk_view_type;
view_desc.layout = base_view->info.texture.vk_layout;
view_desc.format = uint_format;
@ -7178,7 +7178,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ClearUnorderedAccessViewUint(d3
else
{
struct vkd3d_buffer_view_desc view_desc;
view_desc.buffer = resource_impl->vk_buffer;
view_desc.buffer = resource_impl->res.vk_buffer;
view_desc.format = uint_format;
view_desc.offset = base_view->info.buffer.offset;
view_desc.size = base_view->info.buffer.size;
@ -7514,7 +7514,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(d3d12_command_
copy_region.size = stride * query_count;
VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer,
query_heap->vk_buffer, buffer->vk_buffer,
query_heap->vk_buffer, buffer->res.vk_buffer,
1, &copy_region));
}
else
@ -7522,7 +7522,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(d3d12_command_
uint32_t dst_index = aligned_dst_buffer_offset / sizeof(uint64_t);
d3d12_command_list_resolve_binary_occlusion_queries(list,
query_heap->vk_buffer, start_index, buffer->vk_buffer,
query_heap->vk_buffer, start_index, buffer->res.vk_buffer,
buffer->heap_offset, buffer->desc.Width, dst_index,
query_count);
}
@ -7531,7 +7531,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_ResolveQueryData(d3d12_command_
{
d3d12_command_list_read_query_range(list, query_heap->vk_query_pool, start_index, query_count);
VK_CALL(vkCmdCopyQueryPoolResults(list->vk_command_buffer, query_heap->vk_query_pool,
start_index, query_count, buffer->vk_buffer, buffer->heap_offset + aligned_dst_buffer_offset,
start_index, query_count, buffer->res.vk_buffer, buffer->heap_offset + aligned_dst_buffer_offset,
stride, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT));
}
}
@ -7611,7 +7611,7 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetPredication(d3d12_command_li
copy_region.size = sizeof(uint32_t);
VK_CALL(vkCmdCopyBuffer(list->vk_command_buffer,
resource->vk_buffer, scratch.buffer, 1, &copy_region));
resource->res.vk_buffer, scratch.buffer, 1, &copy_region));
src_stages = VK_PIPELINE_STAGE_TRANSFER_BIT;
src_access = VK_ACCESS_TRANSFER_WRITE_BIT;
@ -7831,12 +7831,12 @@ static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(d3d12_command_l
}
else if (count_buffer)
{
scratch.buffer = count_impl->vk_buffer;
scratch.buffer = count_impl->res.vk_buffer;
scratch.offset = count_impl->heap_offset + count_buffer_offset;
}
else
{
scratch.buffer = arg_impl->vk_buffer;
scratch.buffer = arg_impl->res.vk_buffer;
scratch.offset = arg_impl->heap_offset + arg_buffer_offset;
}
@ -7851,13 +7851,13 @@ static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(d3d12_command_l
if (count_buffer || list->predicate_va)
{
VK_CALL(vkCmdDrawIndirectCountKHR(list->vk_command_buffer, arg_impl->vk_buffer,
VK_CALL(vkCmdDrawIndirectCountKHR(list->vk_command_buffer, arg_impl->res.vk_buffer,
arg_buffer_offset + arg_impl->heap_offset, scratch.buffer, scratch.offset,
max_command_count, signature_desc->ByteStride));
}
else
{
VK_CALL(vkCmdDrawIndirect(list->vk_command_buffer, arg_impl->vk_buffer,
VK_CALL(vkCmdDrawIndirect(list->vk_command_buffer, arg_impl->res.vk_buffer,
arg_buffer_offset + arg_impl->heap_offset, max_command_count, signature_desc->ByteStride));
}
break;
@ -7879,13 +7879,13 @@ static void STDMETHODCALLTYPE d3d12_command_list_ExecuteIndirect(d3d12_command_l
if (count_buffer || list->predicate_va)
{
VK_CALL(vkCmdDrawIndexedIndirectCountKHR(list->vk_command_buffer, arg_impl->vk_buffer,
VK_CALL(vkCmdDrawIndexedIndirectCountKHR(list->vk_command_buffer, arg_impl->res.vk_buffer,
arg_buffer_offset + arg_impl->heap_offset, scratch.buffer, scratch.offset,
max_command_count, signature_desc->ByteStride));
}
else
{
VK_CALL(vkCmdDrawIndexedIndirect(list->vk_command_buffer, arg_impl->vk_buffer,
VK_CALL(vkCmdDrawIndexedIndirect(list->vk_command_buffer, arg_impl->res.vk_buffer,
arg_buffer_offset + arg_impl->heap_offset, max_command_count, signature_desc->ByteStride));
}
break;
@ -9257,7 +9257,7 @@ static void d3d12_command_queue_transition_pool_add_barrier(struct d3d12_command
barrier->newLayout = resource->common_layout;
barrier->srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier->image = resource->vk_image;
barrier->image = resource->res.vk_image;
barrier->subresourceRange.aspectMask = resource->format->vk_aspect_mask;
barrier->subresourceRange.baseMipLevel = 0;
barrier->subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
@ -9535,7 +9535,7 @@ static void d3d12_command_queue_bind_sparse(struct d3d12_command_queue *command_
goto cleanup;
}
buffer_info.buffer = dst_resource->vk_buffer;
buffer_info.buffer = dst_resource->res.vk_buffer;
buffer_info.bindCount = count;
buffer_info.pBinds = memory_binds;
@ -9568,7 +9568,7 @@ static void d3d12_command_queue_bind_sparse(struct d3d12_command_queue *command_
goto cleanup;
}
opaque_info.image = dst_resource->vk_image;
opaque_info.image = dst_resource->res.vk_image;
opaque_info.bindCount = opaque_bind_count;
opaque_info.pBinds = memory_binds;
@ -9584,7 +9584,7 @@ static void d3d12_command_queue_bind_sparse(struct d3d12_command_queue *command_
goto cleanup;
}
image_info.image = dst_resource->vk_image;
image_info.image = dst_resource->res.vk_image;
image_info.bindCount = image_bind_count;
image_info.pBinds = image_binds;

53
libs/vkd3d/resource.c
View File

@ -1027,7 +1027,7 @@ static void d3d12_resource_get_tiling(struct d3d12_device *device, struct d3d12_
else
{
VK_CALL(vkGetImageSparseMemoryRequirements(device->vk_device,
resource->vk_image, &memory_requirement_count, NULL));
resource->res.vk_image, &memory_requirement_count, NULL));
if (!memory_requirement_count)
{
@ -1038,7 +1038,7 @@ static void d3d12_resource_get_tiling(struct d3d12_device *device, struct d3d12_
memory_requirements = vkd3d_malloc(memory_requirement_count * sizeof(*memory_requirements));
VK_CALL(vkGetImageSparseMemoryRequirements(device->vk_device,
resource->vk_image, &memory_requirement_count, memory_requirements));
resource->res.vk_image, &memory_requirement_count, memory_requirements));
for (i = 0; i < memory_requirement_count; i++)
{
@ -1275,10 +1275,10 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_SetName(d3d12_resource_iface *if
/* Multiple committed and placed buffers may refer to the same VkBuffer,
* which may cause race conditions if the app calls this concurrently */
if (d3d12_resource_is_buffer(resource) && (resource->flags & VKD3D_RESOURCE_RESERVED))
return vkd3d_set_vk_object_name(resource->device, (uint64_t)resource->vk_buffer,
return vkd3d_set_vk_object_name(resource->device, (uint64_t)resource->res.vk_buffer,
VK_OBJECT_TYPE_BUFFER, name);
else if (d3d12_resource_is_texture(resource))
return vkd3d_set_vk_object_name(resource->device, (uint64_t)resource->vk_image,
return vkd3d_set_vk_object_name(resource->device, (uint64_t)resource->res.vk_image,
VK_OBJECT_TYPE_IMAGE, name);
else
return S_OK;
@ -1505,7 +1505,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_WriteToSubresource(d3d12_resourc
return E_NOTIMPL;
}
VK_CALL(vkGetImageSubresourceLayout(device->vk_device, resource->vk_image, &vk_sub_resource, &vk_layout));
VK_CALL(vkGetImageSubresourceLayout(device->vk_device, resource->res.vk_image, &vk_sub_resource, &vk_layout));
TRACE("Offset %#"PRIx64", size %#"PRIx64", row pitch %#"PRIx64", depth pitch %#"PRIx64".\n",
vk_layout.offset, vk_layout.size, vk_layout.rowPitch, vk_layout.depthPitch);
@ -1584,7 +1584,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(d3d12_resour
return E_NOTIMPL;
}
VK_CALL(vkGetImageSubresourceLayout(device->vk_device, resource->vk_image, &vk_sub_resource, &vk_layout));
VK_CALL(vkGetImageSubresourceLayout(device->vk_device, resource->res.vk_image, &vk_sub_resource, &vk_layout));
TRACE("Offset %#"PRIx64", size %#"PRIx64", row pitch %#"PRIx64", depth pitch %#"PRIx64".\n",
vk_layout.offset, vk_layout.size, vk_layout.rowPitch, vk_layout.depthPitch);
@ -1930,7 +1930,7 @@ static HRESULT d3d12_resource_bind_sparse_metadata(struct d3d12_resource *resour
* drivers, so most of the time we'll just return early. The implementation
* is therefore aimed at simplicity, and not very well tested in practice. */
VK_CALL(vkGetImageSparseMemoryRequirements(device->vk_device,
resource->vk_image, &sparse_requirement_count, NULL));
resource->res.vk_image, &sparse_requirement_count, NULL));
if (!(sparse_requirements = vkd3d_malloc(sparse_requirement_count * sizeof(*sparse_requirements))))
{
@ -1940,7 +1940,7 @@ static HRESULT d3d12_resource_bind_sparse_metadata(struct d3d12_resource *resour
}
VK_CALL(vkGetImageSparseMemoryRequirements(device->vk_device,
resource->vk_image, &sparse_requirement_count, sparse_requirements));
resource->res.vk_image, &sparse_requirement_count, sparse_requirements));
/* Find out how much memory and how many bind infos we need */
metadata_size = 0;
@ -1968,7 +1968,7 @@ static HRESULT d3d12_resource_bind_sparse_metadata(struct d3d12_resource *resour
/* Allocate memory for metadata mip tail */
TRACE("Allocating sparse metadata for resource %p.\n", resource);
VK_CALL(vkGetImageMemoryRequirements(device->vk_device, resource->vk_image, &memory_requirements));
VK_CALL(vkGetImageMemoryRequirements(device->vk_device, resource->res.vk_image, &memory_requirements));
if ((vr = vkd3d_allocate_device_memory(device, metadata_size, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
memory_requirements.memoryTypeBits, NULL, &sparse->vk_metadata_memory, NULL)))
@ -2014,7 +2014,7 @@ static HRESULT d3d12_resource_bind_sparse_metadata(struct d3d12_resource *resour
}
/* Bind metadata memory to the image */
opaque_bind.image = resource->vk_image;
opaque_bind.image = resource->res.vk_image;
opaque_bind.bindCount = bind_count;
opaque_bind.pBinds = memory_binds;
@ -2197,9 +2197,9 @@ static void d3d12_resource_destroy(struct d3d12_resource *resource, struct d3d12
}
if (d3d12_resource_is_texture(resource))
VK_CALL(vkDestroyImage(device->vk_device, resource->vk_image, NULL));
VK_CALL(vkDestroyImage(device->vk_device, resource->res.vk_image, NULL));
else if (resource->flags & VKD3D_RESOURCE_RESERVED)
VK_CALL(vkDestroyBuffer(device->vk_device, resource->vk_buffer, NULL));
VK_CALL(vkDestroyBuffer(device->vk_device, resource->res.vk_buffer, NULL));
if ((resource->flags & VKD3D_RESOURCE_ALLOCATION) && resource->mem.vk_memory)
vkd3d_free_memory(device, &device->memory_allocator, &resource->mem);
@ -2220,7 +2220,7 @@ static HRESULT d3d12_resource_create_vk_resource(struct d3d12_resource *resource
if (resource->desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
{
if (FAILED(hr = vkd3d_create_buffer(device, heap_properties,
D3D12_HEAP_FLAG_NONE, &resource->desc, &resource->vk_buffer)))
D3D12_HEAP_FLAG_NONE, &resource->desc, &resource->res.vk_buffer)))
return hr;
}
else
@ -2231,7 +2231,7 @@ static HRESULT d3d12_resource_create_vk_resource(struct d3d12_resource *resource
resource->desc.MipLevels = max_miplevel_count(&resource->desc);
if (FAILED(hr = vkd3d_create_image(device, heap_properties,
D3D12_HEAP_FLAG_NONE, &resource->desc, resource, &resource->vk_image)))
D3D12_HEAP_FLAG_NONE, &resource->desc, resource, &resource->res.vk_image)))
return hr;
}
@ -2317,7 +2317,7 @@ HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12
else
allocate_info.heap_flags |= D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES;
allocate_info.vk_image = object->vk_image;
allocate_info.vk_image = object->res.vk_image;
if (FAILED(hr = vkd3d_allocate_resource_memory(device,
&device->memory_allocator, &allocate_info, &object->mem)))
@ -2339,7 +2339,7 @@ HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12
&device->memory_allocator, &allocate_info, &object->mem)))
goto fail;
object->vk_buffer = object->mem.resource.vk_buffer;
object->res.vk_buffer = object->mem.resource.vk_buffer;
object->gpu_address = object->mem.resource.va;
object->heap_offset = object->mem.offset;
}
@ -2359,7 +2359,7 @@ static HRESULT d3d12_resource_bind_image_memory(struct d3d12_resource *resource,
VkResult vr;
HRESULT hr;
VK_CALL(vkGetImageMemoryRequirements(device->vk_device, resource->vk_image, &memory_requirements));
VK_CALL(vkGetImageMemoryRequirements(device->vk_device, resource->res.vk_image, &memory_requirements));
/* TODO implement sparse fallback instead to enforce alignment */
if (resource->heap_offset & (memory_requirements.alignment - 1))
@ -2367,7 +2367,7 @@ static HRESULT d3d12_resource_bind_image_memory(struct d3d12_resource *resource,
struct vkd3d_allocate_heap_memory_info allocate_info;
FIXME("Cannot allocate image %p with alignment %#"PRIx64" at heap offset %#"PRIx64", allocating device memory.\n",
resource->vk_image, memory_requirements.alignment, resource->heap_offset);
resource->res.vk_image, memory_requirements.alignment, resource->heap_offset);
memset(&allocate_info, 0, sizeof(allocate_info));
allocate_info.heap_desc.Properties = resource->heap->desc.Properties;
@ -2383,7 +2383,7 @@ static HRESULT d3d12_resource_bind_image_memory(struct d3d12_resource *resource,
resource->heap_offset = resource->mem.offset;
}
if ((vr = VK_CALL(vkBindImageMemory(device->vk_device, resource->vk_image,
if ((vr = VK_CALL(vkBindImageMemory(device->vk_device, resource->res.vk_image,
resource->mem.vk_memory, resource->heap_offset)) < 0))
{
ERR("Failed to bind image memory, vr %d.\n", vr);
@ -2450,7 +2450,7 @@ HRESULT d3d12_resource_create_placed(struct d3d12_device *device, const D3D12_RE
}
else
{
object->vk_buffer = object->mem.resource.vk_buffer;
object->res.vk_buffer = object->mem.resource.vk_buffer;
object->gpu_address = object->mem.resource.va;
}
@ -2481,12 +2481,11 @@ HRESULT d3d12_resource_create_reserved(struct d3d12_device *device,
if (d3d12_resource_is_buffer(object))
{
object->res.vk_buffer = object->vk_buffer;
object->res.cookie = object->cookie;
object->res.size = object->desc.Width;
if (device->device_info.buffer_device_address_features.bufferDeviceAddress)
object->res.va = vkd3d_get_buffer_device_address(device, object->vk_buffer);
object->res.va = vkd3d_get_buffer_device_address(device, object->res.vk_buffer);
else
object->res.va = vkd3d_va_map_alloc_fake_va(&device->memory_allocator.va_map, object->res.size);
@ -2536,7 +2535,7 @@ VKD3D_EXPORT HRESULT vkd3d_create_image_resource(ID3D12Device *device,
object->refcount = 1;
object->internal_refcount = 1;
object->desc = create_info->desc;
object->vk_image = create_info->vk_image;
object->res.vk_image = create_info->vk_image;
object->flags = create_info->flags;
object->flags |= VKD3D_RESOURCE_EXTERNAL;
object->initial_layout_transition = 1;
@ -2940,7 +2939,7 @@ static bool vkd3d_create_buffer_view_for_resource(struct d3d12_device *device,
assert(d3d12_resource_is_buffer(resource));
key.view_type = VKD3D_VIEW_TYPE_BUFFER;
key.u.buffer.buffer = resource->vk_buffer;
key.u.buffer.buffer = resource->res.vk_buffer;
key.u.buffer.format = format;
key.u.buffer.offset = resource->heap_offset + offset * element_size;
key.u.buffer.size = size * element_size;
@ -3099,7 +3098,7 @@ static bool init_default_texture_view_desc(struct vkd3d_texture_view_desc *desc,
return false;
}
desc->image = resource->vk_image;
desc->image = resource->res.vk_image;
desc->layout = resource->common_layout;
desc->miplevel_idx = 0;
desc->miplevel_count = 1;
@ -3281,7 +3280,7 @@ static void vkd3d_buffer_view_get_bound_range_ssbo(struct d3d12_desc *descriptor
VkDeviceSize aligned_end = min((offset + range + alignment - 1) & ~(alignment - 1), resource->desc.Width);
/* heap_offset is guaranteed to have 64KiB alignment */
vk_buffer->buffer = resource->vk_buffer;
vk_buffer->buffer = resource->res.vk_buffer;
vk_buffer->offset = resource->heap_offset + aligned_begin;
vk_buffer->range = aligned_end - aligned_begin;
@ -3843,7 +3842,7 @@ static void vkd3d_create_buffer_uav(struct d3d12_desc *descriptor, struct d3d12_
if (device->bindless_state.flags & VKD3D_RAW_VA_AUX_BUFFER)
{
VkDeviceAddress address = vkd3d_get_buffer_device_address(device, counter_resource->vk_buffer);
VkDeviceAddress address = vkd3d_get_buffer_device_address(device, counter_resource->res.vk_buffer);
uav_counter_address = address + counter_resource->heap_offset + desc->Buffer.CounterOffsetInBytes;
}
else

2
libs/vkd3d/swapchain.c
View File

@ -952,7 +952,7 @@ static HRESULT d3d12_swapchain_create_user_buffers(struct d3d12_swapchain *swapc
return hr;
}
swapchain->vk_images[i] = object->vk_image;
swapchain->vk_images[i] = object->res.vk_image;
swapchain->buffers[i] = (ID3D12Resource *)&object->ID3D12Resource_iface;
vkd3d_resource_incref(swapchain->buffers[i]);

7
libs/vkd3d/vkd3d_private.h
View File

@ -687,11 +687,6 @@ struct d3d12_resource
D3D12_GPU_VIRTUAL_ADDRESS gpu_address;
struct vkd3d_memory_allocation mem;
struct vkd3d_unique_resource res;
union
{
VkBuffer vk_buffer;
VkImage vk_image;
};
struct d3d12_heap *heap;
uint64_t heap_offset;
@ -2586,7 +2581,7 @@ VkDeviceAddress vkd3d_get_buffer_device_address(struct d3d12_device *device, VkB
static inline VkDeviceAddress d3d12_resource_get_va(const struct d3d12_resource *resource, VkDeviceSize offset)
{
return vkd3d_get_buffer_device_address(resource->device, resource->vk_buffer) + resource->heap_offset + offset;
return vkd3d_get_buffer_device_address(resource->device, resource->res.vk_buffer) + resource->heap_offset + offset;
}
static inline unsigned int vkd3d_compute_workgroup_count(unsigned int thread_count, unsigned int workgroup_size)