wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-01-28 13:05:02 -08:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d: Support multiple descriptions in GetResourceAllocationInfo().

Browse Source
This commit is contained in:
Conor McCarthy 2024-01-31 00:27:54 +10:00 committed by Alexandre Julliard
parent 8d0331df6c
commit 7e84421b9c
Notes: Alexandre Julliard 2024-02-01 23:07:43 +01:00 
Approved-by: Henri Verbeet (@hverbeet)
Approved-by: Alexandre Julliard (@julliard)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/617
4 changed files with 89 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
libs/vkd3d/device.c
View File

@ -1969,7 +1969,7 @@ static HRESULT vkd3d_select_queues(const struct vkd3d_instance *vkd3d_instance,
* which applies to resources of a total size of 4 MiB or less. */ * which applies to resources of a total size of 4 MiB or less. */
static bool d3d12_is_64k_msaa_supported(struct d3d12_device *device) static bool d3d12_is_64k_msaa_supported(struct d3d12_device *device)
{ {
D3D12_RESOURCE_ALLOCATION_INFO info; struct vkd3d_resource_allocation_info info;
D3D12_RESOURCE_DESC resource_desc; D3D12_RESOURCE_DESC resource_desc;
memset(&resource_desc, 0, sizeof(resource_desc)); memset(&resource_desc, 0, sizeof(resource_desc));
@ -1986,7 +1986,7 @@ static bool d3d12_is_64k_msaa_supported(struct d3d12_device *device)
* resources, which must have 0x10000 in their description, so we might * resources, which must have 0x10000 in their description, so we might
* reasonably return true here for 0x20000 or 0x40000. */ * reasonably return true here for 0x20000 or 0x40000. */
return SUCCEEDED(vkd3d_get_image_allocation_info(device, &resource_desc, &info)) return SUCCEEDED(vkd3d_get_image_allocation_info(device, &resource_desc, &info))
&& info.Alignment <= 0x10000; && info.alignment <= 0x10000;
} }
static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, static HRESULT vkd3d_create_vk_device(struct d3d12_device *device,
@ -3566,29 +3566,23 @@ static void STDMETHODCALLTYPE d3d12_device_CopyDescriptorsSimple(ID3D12Device7 *
1, &src_descriptor_range_offset, &descriptor_count, descriptor_heap_type); 1, &src_descriptor_range_offset, &descriptor_count, descriptor_heap_type);
} }
static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResourceAllocationInfo( static void d3d12_device_get_resource_allocation_info(struct d3d12_device *device,
ID3D12Device7 *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, unsigned int count, const D3D12_RESOURCE_DESC *resource_descs,
UINT count, const D3D12_RESOURCE_DESC *resource_descs) D3D12_RESOURCE_ALLOCATION_INFO *result)
{ {
struct d3d12_device *device = impl_from_ID3D12Device7(iface); struct vkd3d_resource_allocation_info info;
const D3D12_RESOURCE_DESC *desc; const D3D12_RESOURCE_DESC *desc;
uint64_t requested_alignment; uint64_t requested_alignment;
unsigned int i;
TRACE("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p.\n", result->Alignment = 0;
iface, info, visible_mask, count, resource_descs); result->SizeInBytes = 0;
debug_ignored_node_mask(visible_mask); info.offset = 0;
info->SizeInBytes = 0; for (i = 0; i < count; ++i)
info->Alignment = 0;
if (count != 1)
{ {
FIXME("Multiple resource descriptions not supported.\n"); desc = &resource_descs[i];
return info;
}
desc = &resource_descs[0];
if (FAILED(d3d12_resource_validate_desc(desc, device))) if (FAILED(d3d12_resource_validate_desc(desc, device)))
{ {
@ -3598,12 +3592,13 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour
if (desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) if (desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
{ {
info->SizeInBytes = align(desc->Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT); info.alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
info->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; info.offset = align(info.offset, info.alignment);
info.size_in_bytes = align(desc->Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT);
} }
else else
{ {
if (FAILED(vkd3d_get_image_allocation_info(device, desc, info))) if (FAILED(vkd3d_get_image_allocation_info(device, desc, &info)))
{ {
WARN("Failed to get allocation info for texture.\n"); WARN("Failed to get allocation info for texture.\n");
goto invalid; goto invalid;
@ -3611,34 +3606,53 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour
requested_alignment = desc->Alignment requested_alignment = desc->Alignment
? desc->Alignment : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; ? desc->Alignment : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
info->Alignment = max(info->Alignment, requested_alignment); info.alignment = max(info.alignment, requested_alignment);
info.size_in_bytes = align(info.size_in_bytes, info.alignment);
info->SizeInBytes = align(info->SizeInBytes, info->Alignment);
/* Pad by the maximum heap offset increase which may be needed to align to a higher /* Pad by the maximum heap offset increase which may be needed to align to a higher
* Vulkan requirement an offset supplied by the calling application. This allows * Vulkan requirement an offset supplied by the calling application. This allows
* us to return the standard D3D12 alignment and adjust resource placement later. */ * us to return the standard D3D12 alignment and adjust resource placement later. */
if (info->Alignment > requested_alignment) if (info.alignment > requested_alignment)
{ {
info->SizeInBytes += info->Alignment - requested_alignment; info.size_in_bytes += info.alignment - requested_alignment;
info->Alignment = requested_alignment; info.alignment = requested_alignment;
}
} }
TRACE("Size %#"PRIx64", alignment %#"PRIx64".\n", info->SizeInBytes, info->Alignment); info.offset = align(info.offset, info.alignment);
}
return info; info.offset += info.size_in_bytes;
result->Alignment = max(result->Alignment, info.alignment);
result->SizeInBytes = info.offset;
}
return;
invalid: invalid:
info->SizeInBytes = ~(uint64_t)0; result->SizeInBytes = UINT64_MAX;
/* FIXME: Should we support D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT for small MSSA resources? */ /* FIXME: Should we support D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT for small MSAA resources? */
if (desc->SampleDesc.Count != 1) if (desc->SampleDesc.Count != 1)
info->Alignment = D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT; result->Alignment = D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT;
else else
info->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; result->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
TRACE("Alignment %#"PRIx64".\n", info->Alignment); TRACE("Alignment %#"PRIx64".\n", result->Alignment);
}
static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResourceAllocationInfo(
ID3D12Device7 *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask,
UINT count, const D3D12_RESOURCE_DESC *resource_descs)
{
struct d3d12_device *device = impl_from_ID3D12Device7(iface);
TRACE("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p.\n",
iface, info, visible_mask, count, resource_descs);
debug_ignored_node_mask(visible_mask);
d3d12_device_get_resource_allocation_info(device, count, resource_descs, info);
return info; return info;
} }

6
libs/vkd3d/resource.c
View File

@ -940,7 +940,7 @@ static HRESULT vkd3d_create_image(struct d3d12_device *device,
} }
HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device,
const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) const D3D12_RESOURCE_DESC *desc, struct vkd3d_resource_allocation_info *allocation_info)
{ {
static const D3D12_HEAP_PROPERTIES heap_properties = {D3D12_HEAP_TYPE_DEFAULT}; static const D3D12_HEAP_PROPERTIES heap_properties = {D3D12_HEAP_TYPE_DEFAULT};
const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
@ -968,8 +968,8 @@ HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device,
VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &requirements)); VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &requirements));
VK_CALL(vkDestroyImage(device->vk_device, vk_image, NULL)); VK_CALL(vkDestroyImage(device->vk_device, vk_image, NULL));
allocation_info->SizeInBytes = requirements.size; allocation_info->size_in_bytes = requirements.size;
allocation_info->Alignment = requirements.alignment; allocation_info->alignment = requirements.alignment;
} }
return hr; return hr;

9
libs/vkd3d/vkd3d_private.h
View File

@ -770,6 +770,13 @@ static inline bool d3d12_resource_is_texture(const struct d3d12_resource *resour
return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER; return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER;
} }
struct vkd3d_resource_allocation_info
{
uint64_t offset;
uint64_t alignment;
uint64_t size_in_bytes;
};
bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource); bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource);
HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device); HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device);
void d3d12_resource_get_tiling(struct d3d12_device *device, const struct d3d12_resource *resource, void d3d12_resource_get_tiling(struct d3d12_device *device, const struct d3d12_resource *resource,
@ -797,7 +804,7 @@ HRESULT vkd3d_create_buffer(struct d3d12_device *device,
const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer); const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer);
HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device,
const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info); const D3D12_RESOURCE_DESC *desc, struct vkd3d_resource_allocation_info *allocation_info);
enum vkd3d_view_type enum vkd3d_view_type
{ {

2
tests/d3d12.c
View File

@ -32284,11 +32284,9 @@ static void test_resource_allocation_info(void)
: D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
} }
info = ID3D12Device_GetResourceAllocationInfo(device, 0, ARRAY_SIZE(desc_array), desc_array); info = ID3D12Device_GetResourceAllocationInfo(device, 0, ARRAY_SIZE(desc_array), desc_array);
todo
ok(info.Alignment >= D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, ok(info.Alignment >= D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
"Got unexpected alignment %"PRIu64".\n", info.Alignment); "Got unexpected alignment %"PRIu64".\n", info.Alignment);
check_alignment(info.SizeInBytes, info.Alignment); check_alignment(info.SizeInBytes, info.Alignment);
todo
ok(info.SizeInBytes >= total, "Got unexpected size %"PRIu64".\n", info.SizeInBytes); ok(info.SizeInBytes >= total, "Got unexpected size %"PRIu64".\n", info.SizeInBytes);
refcount = ID3D12Device_Release(device); refcount = ID3D12Device_Release(device);