wine-commits September 2018

wine-commits@winehq.org

2 participants
670 discussions

Henri Verbeet : wined3d: Support NPOT textures on NO3D adapters.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: wine Branch: master Commit: c4ae8973b18cb19d5d70b4783141cc6bd6cce1c9 URL: https://source.winehq.org/git/wine.git/?a=commit;h=c4ae8973b18cb19d5d70b478… Author: Henri Verbeet <hverbeet(a)codeweavers.com> Date: Wed Sep 26 01:02:34 2018 +0330 wined3d: Support NPOT textures on NO3D adapters. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/wined3d/directx.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 97037b6..c25d847 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2464,6 +2464,7 @@ static void wined3d_adapter_no3d_init_d3d_info(struct wined3d_adapter *adapter, struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; d3d_info->wined3d_creation_flags = wined3d_creation_flags; + d3d_info->texture_npot = TRUE; } static BOOL wined3d_adapter_no3d_init(struct wined3d_adapter *adapter, DWORD wined3d_creation_flags)

1 0

Michael Stefaniuc : winhttp: Use the ARRAY_SIZE() macro.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: wine Branch: master Commit: 9c1298a0e5b88e3add137f0c14a3c5cedd6e206a URL: https://source.winehq.org/git/wine.git/?a=commit;h=9c1298a0e5b88e3add137f0c… Author: Michael Stefaniuc <mstefani(a)winehq.org> Date: Tue Sep 25 19:35:02 2018 +0200 winhttp: Use the ARRAY_SIZE() macro. Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/winhttp/cookie.c | 2 +- dlls/winhttp/net.c | 8 ++++---- dlls/winhttp/request.c | 6 +++--- dlls/winhttp/url.c | 2 +- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/dlls/winhttp/cookie.c b/dlls/winhttp/cookie.c index e8cc89f..59d098f 100644 --- a/dlls/winhttp/cookie.c +++ b/dlls/winhttp/cookie.c @@ -312,7 +312,7 @@ BOOL add_cookie_headers( request_t *request ) if (strstrW( request->path, cookie->path ) == request->path) { const WCHAR cookieW[] = {'C','o','o','k','i','e',':',' '}; - int len, len_cookie = sizeof(cookieW) / sizeof(cookieW[0]), len_name = strlenW( cookie->name ); + int len, len_cookie = ARRAY_SIZE( cookieW ), len_name = strlenW( cookie->name ); WCHAR *header; len = len_cookie + len_name; diff --git a/dlls/winhttp/net.c b/dlls/winhttp/net.c index 020ec5b..8f66847 100644 --- a/dlls/winhttp/net.c +++ b/dlls/winhttp/net.c @@ -397,7 +397,7 @@ static BOOL send_ssl_chunk(netconn_t *conn, const void *msg, size_t size) {conn->ssl_sizes.cbTrailer, SECBUFFER_STREAM_TRAILER, conn->ssl_buf+conn->ssl_sizes.cbHeader+size}, {0, SECBUFFER_EMPTY, NULL} }; - SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs}; + SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs}; SECURITY_STATUS res; memcpy(bufs[1].pvBuffer, msg, size); @@ -443,7 +443,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, SIZE_T * { const SIZE_T ssl_buf_size = conn->ssl_sizes.cbHeader+conn->ssl_sizes.cbMaximumMessage+conn->ssl_sizes.cbTrailer; SecBuffer bufs[4]; - SecBufferDesc buf_desc = {SECBUFFER_VERSION, sizeof(bufs)/sizeof(*bufs), bufs}; + SecBufferDesc buf_desc = {SECBUFFER_VERSION, ARRAY_SIZE(bufs), bufs}; SSIZE_T size, buf_len; unsigned int i; SECURITY_STATUS res; @@ -499,7 +499,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, SIZE_T * } } while(res != SEC_E_OK); - for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) { + for(i = 0; i < ARRAY_SIZE(bufs); i++) { if(bufs[i].BufferType == SECBUFFER_DATA) { size = min(buf_size, bufs[i].cbBuffer); memcpy(buf, bufs[i].pvBuffer, size); @@ -516,7 +516,7 @@ static BOOL read_ssl_chunk(netconn_t *conn, void *buf, SIZE_T buf_size, SIZE_T * } } - for(i=0; i < sizeof(bufs)/sizeof(*bufs); i++) { + for(i = 0; i < ARRAY_SIZE(bufs); i++) { if(bufs[i].BufferType == SECBUFFER_EXTRA) { conn->extra_buf = heap_alloc(bufs[i].cbBuffer); if(!conn->extra_buf) diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c index 24e4b55..a365cdb 100644 --- a/dlls/winhttp/request.c +++ b/dlls/winhttp/request.c @@ -747,7 +747,7 @@ static BOOL query_headers( request_t *request, DWORD level, LPCWSTR name, LPVOID return ret; default: - if (attr >= sizeof(attribute_table)/sizeof(attribute_table[0]) || !attribute_table[attr]) + if (attr >= ARRAY_SIZE(attribute_table) || !attribute_table[attr]) { FIXME("attribute %u not implemented\n", attr); return FALSE; @@ -3120,7 +3120,7 @@ void release_typelib(void) { unsigned i; - for (i = 0; i < sizeof(winhttp_typeinfo)/sizeof(*winhttp_typeinfo); i++) + for (i = 0; i < ARRAY_SIZE(winhttp_typeinfo); i++) if (winhttp_typeinfo[i]) ITypeInfo_Release(winhttp_typeinfo[i]); @@ -3446,7 +3446,7 @@ static HRESULT WINAPI winhttp_request_Open( goto error; } - len = sizeof(httpsW) / sizeof(WCHAR); + len = ARRAY_SIZE( httpsW ); if (uc.dwSchemeLength == len && !memcmp( uc.lpszScheme, httpsW, len * sizeof(WCHAR) )) { flags |= WINHTTP_FLAG_SECURE; diff --git a/dlls/winhttp/url.c b/dlls/winhttp/url.c index 9e040bc..1e481d7 100644 --- a/dlls/winhttp/url.c +++ b/dlls/winhttp/url.c @@ -479,7 +479,7 @@ BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDW if (uc->lpszHostName) { memcpy( url, twoslashW, sizeof(twoslashW) ); - url += sizeof(twoslashW) / sizeof(twoslashW[0]); + url += ARRAY_SIZE( twoslashW ); } if (uc->lpszUserName) {

1 0

Michael Stefaniuc : winhttp: Avoid a variable that holds an ARRAY_SIZE() result.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: wine Branch: master Commit: 8c8ea309a41d69efb13d353c3cc0c51fef72041a URL: https://source.winehq.org/git/wine.git/?a=commit;h=8c8ea309a41d69efb13d353c… Author: Michael Stefaniuc <mstefani(a)winehq.org> Date: Tue Sep 25 19:35:01 2018 +0200 winhttp: Avoid a variable that holds an ARRAY_SIZE() result. Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/winhttp/request.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/dlls/winhttp/request.c b/dlls/winhttp/request.c index 33d8682..24e4b55 100644 --- a/dlls/winhttp/request.c +++ b/dlls/winhttp/request.c @@ -866,13 +866,12 @@ auth_schemes[] = { digestW, ARRAY_SIZE(digestW) - 1, WINHTTP_AUTH_SCHEME_DIGEST }, { negotiateW, ARRAY_SIZE(negotiateW) - 1, WINHTTP_AUTH_SCHEME_NEGOTIATE } }; -static const unsigned int num_auth_schemes = sizeof(auth_schemes)/sizeof(auth_schemes[0]); static enum auth_scheme scheme_from_flag( DWORD flag ) { int i; - for (i = 0; i < num_auth_schemes; i++) if (flag == auth_schemes[i].scheme) return i; + for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++) if (flag == auth_schemes[i].scheme) return i; return SCHEME_INVALID; } @@ -880,7 +879,7 @@ static DWORD auth_scheme_from_header( WCHAR *header ) { unsigned int i; - for (i = 0; i < num_auth_schemes; i++) + for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++) { if (!strncmpiW( header, auth_schemes[i].str, auth_schemes[i].len ) && (header[auth_schemes[i].len] == ' ' || !header[auth_schemes[i].len])) return auth_schemes[i].scheme; @@ -2310,7 +2309,7 @@ static BOOL handle_authorization( request_t *request, DWORD status ) if (do_authorization( request, target, first )) return TRUE; schemes &= ~first; - for (i = 0; i < num_auth_schemes; i++) + for (i = 0; i < ARRAY_SIZE( auth_schemes ); i++) { if (!(schemes & auth_schemes[i].scheme)) continue; if (do_authorization( request, target, auth_schemes[i].scheme )) return TRUE;

1 0

Józef Kucia : tests: Add test for GetResourceAllocationInfo().
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: 8378ec758d3020a9687310d48f102e3344e478df URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=8378ec758d3020a9687310d… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:07 2018 +0200 tests: Add test for GetResourceAllocationInfo(). Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- tests/d3d12.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 6103010..69b9fe7 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -19558,6 +19558,79 @@ static void test_combined_clip_and_cull_distances(void) destroy_test_context(&context); } +static void test_resource_allocation_info(void) +{ + D3D12_RESOURCE_ALLOCATION_INFO info; + D3D12_RESOURCE_DESC desc; + ID3D12Device *device; + unsigned int i, j; + ULONG refcount; + + static const unsigned int alignments[] = + { + 0, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT, + }; + static const unsigned int buffer_sizes[] = + { + 1, + 16, + 256, + 1024, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT + 1, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT + 1, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT, + D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT + 1, + }; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + desc.Alignment = 0; + desc.Width = 32; + desc.Height = 1; + desc.DepthOrArraySize = 1; + desc.MipLevels = 1; + desc.Format = DXGI_FORMAT_UNKNOWN; + desc.SampleDesc.Count = 1; + desc.SampleDesc.Quality = 0; + desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + desc.Flags = 0; + + for (i = 0; i < ARRAY_SIZE(alignments); ++i) + { + for (j = 0; j < ARRAY_SIZE(buffer_sizes); ++j) + { + desc.Alignment = alignments[i]; + desc.Width = buffer_sizes[j]; + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &desc); + if (!desc.Alignment || desc.Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT) + { + check_alignment(info.SizeInBytes, info.Alignment); + } + else + { + ok(info.SizeInBytes == ~(UINT64)0, + "Got unexpected size %"PRIu64".\n", info.SizeInBytes); + ok(info.Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, + "Got unexpected alignment %"PRIu64".\n", info.Alignment); + } + } + } + + + refcount = ID3D12Device_Release(device); + ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); +} + static void test_suballocate_small_textures(void) { D3D12_GPU_VIRTUAL_ADDRESS gpu_address; @@ -19758,5 +19831,6 @@ START_TEST(d3d12) run_test(test_cpu_descriptors_lifetime); run_test(test_clip_distance); run_test(test_combined_clip_and_cull_distances); + run_test(test_resource_allocation_info); run_test(test_suballocate_small_textures); }

1 0

Józef Kucia : tests: Add test for suballocation of small textures.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: 957e76dddc0f862ff653f9e05a44e8e27f13b29d URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=957e76dddc0f862ff653f9e… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:06 2018 +0200 tests: Add test for suballocation of small textures. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- tests/d3d12.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 5f2d2d8..6103010 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -193,6 +193,14 @@ static void check_heap_desc_(unsigned int line, const D3D12_HEAP_DESC *desc, "Got flags %#x, expected %#x.\n", desc->Flags, expected.Flags); } +#define check_alignment(a, b) check_alignment_(__LINE__, a, b) +static void check_alignment_(unsigned int line, uint64_t size, uint64_t alignment) +{ + uint64_t aligned_size = align(size, alignment); + ok_(line)(aligned_size == size, "Got unaligned size %"PRIu64", expected %"PRIu64".\n", + size, aligned_size); +} + static void uav_barrier(ID3D12GraphicsCommandList *list, ID3D12Resource *resource) { D3D12_RESOURCE_BARRIER barrier; @@ -19550,6 +19558,89 @@ static void test_combined_clip_and_cull_distances(void) destroy_test_context(&context); } +static void test_suballocate_small_textures(void) +{ + D3D12_GPU_VIRTUAL_ADDRESS gpu_address; + D3D12_RESOURCE_ALLOCATION_INFO info; + D3D12_RESOURCE_DESC resource_desc; + ID3D12Resource *textures[10]; + D3D12_HEAP_DESC heap_desc; + ID3D12Device *device; + ID3D12Heap *heap; + unsigned int i; + ULONG refcount; + HRESULT hr; + + if (!(device = create_device())) + { + skip("Failed to create device.\n"); + return; + } + + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resource_desc.Alignment = 0; + resource_desc.Width = 32; + resource_desc.Height = 32; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + resource_desc.SampleDesc.Count = 1; + resource_desc.SampleDesc.Quality = 0; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + resource_desc.Flags = 0; + + resource_desc.Alignment = D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT; + + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &resource_desc); + trace("Size %"PRIu64", alignment %"PRIu64".\n", info.SizeInBytes, info.Alignment); + check_alignment(info.SizeInBytes, info.Alignment); + if (info.Alignment != D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT) + { + resource_desc.Alignment = 0; + info = ID3D12Device_GetResourceAllocationInfo(device, 0, 1, &resource_desc); + trace("Size %"PRIu64", alignment %"PRIu64".\n", info.SizeInBytes, info.Alignment); + check_alignment(info.SizeInBytes, info.Alignment); + } + + heap_desc.SizeInBytes = ARRAY_SIZE(textures) * info.SizeInBytes; + memset(&heap_desc.Properties, 0, sizeof(heap_desc.Properties)); + heap_desc.Properties.Type = D3D12_HEAP_TYPE_DEFAULT; + heap_desc.Alignment = 0; + heap_desc.Flags = D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES; + hr = ID3D12Device_CreateHeap(device, &heap_desc, &IID_ID3D12Heap, (void **)&heap); + ok(hr == S_OK, "Failed to create heap, hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + hr = ID3D12Device_CreatePlacedResource(device, heap, i * info.SizeInBytes, + &resource_desc, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, + NULL, &IID_ID3D12Resource, (void **)&textures[i]); + ok(hr == S_OK, "Failed to create placed resource %u, hr %#x.\n", i, hr); + + check_interface(textures[i], &IID_ID3D12Object, TRUE); + check_interface(textures[i], &IID_ID3D12DeviceChild, TRUE); + check_interface(textures[i], &IID_ID3D12Pageable, TRUE); + check_interface(textures[i], &IID_ID3D12Resource, TRUE); + + gpu_address = ID3D12Resource_GetGPUVirtualAddress(textures[i]); + ok(!gpu_address, "Got unexpected GPU virtual address %#"PRIx64".\n", gpu_address); + } + + refcount = get_refcount(heap); + ok(refcount == 1, "Got unexpected refcount %u.\n", (unsigned int)refcount); + + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + refcount = ID3D12Resource_Release(textures[i]); + ok(!refcount, "ID3D12Resource has %u references left.\n", (unsigned int)refcount); + } + + refcount = ID3D12Heap_Release(heap); + ok(!refcount, "ID3D12Heap has %u references left.\n", (unsigned int)refcount); + refcount = ID3D12Device_Release(device); + ok(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); +} + START_TEST(d3d12) { bool enable_debug_layer = false; @@ -19667,4 +19758,5 @@ START_TEST(d3d12) run_test(test_cpu_descriptors_lifetime); run_test(test_clip_distance); run_test(test_combined_clip_and_cull_distances); + run_test(test_suballocate_small_textures); }

1 0

Józef Kucia : vkd3d: Add WARN() for " out of device memory" errors.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: b7ed0df1f4faae54bea66c2965ceb8f52ae1c637 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=b7ed0df1f4faae54bea66c2… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:05 2018 +0200 vkd3d: Add WARN() for "out of device memory" errors. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- libs/vkd3d/utils.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index 682822e..05d15b2 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -387,8 +387,9 @@ HRESULT hresult_from_vk_result(VkResult vr) { case VK_SUCCESS: return S_OK; - case VK_ERROR_OUT_OF_HOST_MEMORY: case VK_ERROR_OUT_OF_DEVICE_MEMORY: + WARN("Out of device memory.\n"); + case VK_ERROR_OUT_OF_HOST_MEMORY: return E_OUTOFMEMORY; default: FIXME("Unhandled VkResult %d.\n", vr);

1 0

Józef Kucia : vkd3d: Use heap memory for placed resources.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: 413c8562b987c8368138372d0a4ab682d74f1f46 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=413c8562b987c8368138372… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Wed Sep 26 09:10:31 2018 +0200 vkd3d: Use heap memory for placed resources. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- libs/vkd3d/resource.c | 95 ++++++++++++++++++++++++++++++++++++---------- libs/vkd3d/vkd3d_private.h | 1 + 2 files changed, 77 insertions(+), 19 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 272fa70..98c703a 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -57,7 +57,7 @@ static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32 static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory) + const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory, uint32_t *vk_memory_type) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; VkMemoryAllocateInfo allocate_info; @@ -88,6 +88,9 @@ static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, return hresult_from_vk_result(vr); } + if (vk_memory_type) + *vk_memory_type = allocate_info.memoryTypeIndex; + return S_OK; } @@ -284,7 +287,7 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, memory_requirements.memoryTypeBits = ~(uint32_t)0; if (FAILED(hr = vkd3d_allocate_device_memory(device, &heap->desc.Properties, - heap->desc.Flags, &memory_requirements, &heap->vk_memory))) + heap->desc.Flags, &memory_requirements, &heap->vk_memory, &heap->vk_memory_type))) return hr; heap->device = device; @@ -529,7 +532,7 @@ HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_bu VK_CALL(vkGetBufferMemoryRequirements(device->vk_device, vk_buffer, &memory_requirements)); if (FAILED(hr = vkd3d_allocate_device_memory(device, heap_properties, heap_flags, - &memory_requirements, vk_memory))) + &memory_requirements, vk_memory, NULL))) return hr; if ((vr = VK_CALL(vkBindBufferMemory(device->vk_device, vk_buffer, *vk_memory, 0))) < 0) @@ -554,7 +557,7 @@ static HRESULT vkd3d_allocate_image_memory(struct d3d12_device *device, VkImage VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &memory_requirements)); if (FAILED(hr = vkd3d_allocate_device_memory(device, heap_properties, heap_flags, - &memory_requirements, vk_memory))) + &memory_requirements, vk_memory, NULL))) return hr; if ((vr = VK_CALL(vkBindImageMemory(device->vk_device, vk_image, *vk_memory, 0))) < 0) @@ -1056,6 +1059,22 @@ static HRESULT d3d12_resource_create(struct d3d12_device *device, return hr; } +static HRESULT vkd3d_allocate_resource_memory( + struct d3d12_device *device, struct d3d12_resource *resource, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) +{ + if (d3d12_resource_is_buffer(resource)) + { + return vkd3d_allocate_buffer_memory(device, resource->u.vk_buffer, + heap_properties, heap_flags, &resource->vk_memory); + } + else + { + return vkd3d_allocate_image_memory(device, resource->u.vk_image, + heap_properties, heap_flags, &resource->vk_memory); + } +} + HRESULT d3d12_committed_resource_create(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, @@ -1068,40 +1087,78 @@ HRESULT d3d12_committed_resource_create(struct d3d12_device *device, desc, initial_state, optimized_clear_value, &object))) return hr; - if (d3d12_resource_is_buffer(object)) + if (FAILED(hr = vkd3d_allocate_resource_memory(device, object, heap_properties, heap_flags))) { - hr = vkd3d_allocate_buffer_memory(device, object->u.vk_buffer, - heap_properties, heap_flags, &object->vk_memory); + d3d12_resource_Release(&object->ID3D12Resource_iface); + return hr; } + + TRACE("Created committed resource %p.\n", object); + + *resource = object; + + return S_OK; +} + +static HRESULT vkd3d_bind_heap_memory(struct d3d12_device *device, + struct d3d12_resource *resource, struct d3d12_heap *heap, UINT64 heap_offset) +{ + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkDevice vk_device = device->vk_device; + VkMemoryRequirements requirements; + VkResult vr; + + if (d3d12_resource_is_buffer(resource)) + VK_CALL(vkGetBufferMemoryRequirements(vk_device, resource->u.vk_buffer, &requirements)); else + VK_CALL(vkGetImageMemoryRequirements(vk_device, resource->u.vk_image, &requirements)); + + if (heap_offset % requirements.alignment) { - hr = vkd3d_allocate_image_memory(device, object->u.vk_image, - heap_properties, heap_flags, &object->vk_memory); + FIXME("Invalid heap offset %#"PRIx64".\n", heap_offset); + return E_INVALIDARG; } - if (FAILED(hr)) + if (!(requirements.memoryTypeBits & (1u << heap->vk_memory_type))) { - d3d12_resource_Release(&object->ID3D12Resource_iface); - return hr; + FIXME("Memory type %u cannot be bound to resource %p (allowed types %#x).\n", + heap->vk_memory_type, resource, requirements.memoryTypeBits); + return E_NOTIMPL; } - TRACE("Created committed resource %p.\n", object); + if (d3d12_resource_is_buffer(resource)) + vr = VK_CALL(vkBindBufferMemory(vk_device, resource->u.vk_buffer, heap->vk_memory, heap_offset)); + else + vr = VK_CALL(vkBindImageMemory(vk_device, resource->u.vk_image, heap->vk_memory, heap_offset)); - *resource = object; + if (vr < 0) + WARN("Failed to bind memory, vr %d.\n", vr); - return S_OK; + return hresult_from_vk_result(vr); } HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, UINT64 heap_offset, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) { - const D3D12_HEAP_DESC *heap_desc = &heap->desc; + struct d3d12_resource *object; + HRESULT hr; - FIXME("Ignoring heap %p, offset %"PRIu64".\n", heap, heap_offset); + if (FAILED(hr = d3d12_resource_create(device, &heap->desc.Properties, heap->desc.Flags, + desc, initial_state, optimized_clear_value, &object))) + return hr; - return d3d12_committed_resource_create(device, &heap_desc->Properties, heap_desc->Flags, - desc, initial_state, optimized_clear_value, resource); + if (FAILED(hr = vkd3d_bind_heap_memory(device, object, heap, heap_offset))) + { + d3d12_resource_Release(&object->ID3D12Resource_iface); + return hr; + } + + TRACE("Created placed resource %p.\n", object); + + *resource = object; + + return S_OK; } HRESULT vkd3d_create_image_resource(ID3D12Device *device, diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 4865671..aca0e50 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -191,6 +191,7 @@ struct d3d12_heap D3D12_HEAP_DESC desc; VkDeviceMemory vk_memory; + uint32_t vk_memory_type; struct d3d12_device *device; };

1 0

Józef Kucia : vkd3d: Allocate device memory for heaps.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: bd0ce54f7944095ef4fb504f27c7a1af4f17ab0a URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=bd0ce54f7944095ef4fb504… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:03 2018 +0200 vkd3d: Allocate device memory for heaps. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- libs/vkd3d/resource.c | 158 ++++++++++++++++++++++++--------------------- libs/vkd3d/vkd3d_private.h | 2 + 2 files changed, 87 insertions(+), 73 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 82ff701..272fa70 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -18,6 +18,79 @@ #include "vkd3d_private.h" +static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) +{ + VkPhysicalDeviceMemoryProperties *memory_info = &device->memory_properties; + VkMemoryPropertyFlags required_flags; + unsigned int i; + + switch (heap_properties->Type) + { + case D3D12_HEAP_TYPE_DEFAULT: + required_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + break; + + case D3D12_HEAP_TYPE_CUSTOM: + FIXME("Custom heaps not supported yet.\n"); + /* fall-through */ + case D3D12_HEAP_TYPE_UPLOAD: + case D3D12_HEAP_TYPE_READBACK: + required_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + break; + + default: + WARN("Invalid heap type %#x.\n", heap_properties->Type); + return ~0u; + } + + for (i = 0; i < memory_info->memoryTypeCount; ++i) + { + if (!(memory_type_mask & (1u << i))) + continue; + if ((memory_info->memoryTypes[i].propertyFlags & required_flags) == required_flags) + return i; + } + + return ~0u; +} + +static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory) +{ + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkMemoryAllocateInfo allocate_info; + VkResult vr; + + TRACE("Memory requirements: size %#"PRIx64", alignment %#"PRIx64".\n", + memory_requirements->size, memory_requirements->alignment); + + allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocate_info.pNext = NULL; + allocate_info.allocationSize = memory_requirements->size; + allocate_info.memoryTypeIndex = vkd3d_select_memory_type(device, + memory_requirements->memoryTypeBits, heap_properties, heap_flags); + + if (allocate_info.memoryTypeIndex == ~0u) + { + FIXME("Failed to find suitable memory type (allowed types %#x).\n", memory_requirements->memoryTypeBits); + *vk_memory = VK_NULL_HANDLE; + return E_FAIL; + } + + TRACE("Allocating memory type %u.\n", allocate_info.memoryTypeIndex); + + if ((vr = VK_CALL(vkAllocateMemory(device->vk_device, &allocate_info, NULL, vk_memory))) < 0) + { + WARN("Failed to allocate device memory, vr %d.\n", vr); + *vk_memory = VK_NULL_HANDLE; + return hresult_from_vk_result(vr); + } + + return S_OK; +} + /* ID3D12Heap */ static inline struct d3d12_heap *impl_from_ID3D12Heap(ID3D12Heap *iface) { @@ -66,6 +139,9 @@ static ULONG STDMETHODCALLTYPE d3d12_heap_Release(ID3D12Heap *iface) if (!refcount) { struct d3d12_device *device = heap->device; + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + + VK_CALL(vkFreeMemory(device->vk_device, heap->vk_memory, NULL)); vkd3d_free(heap); @@ -181,6 +257,7 @@ static HRESULT validate_heap_desc(const D3D12_HEAP_DESC *desc) static HRESULT d3d12_heap_init(struct d3d12_heap *heap, struct d3d12_device *device, const D3D12_HEAP_DESC *desc) { + VkMemoryRequirements memory_requirements; HRESULT hr; heap->ID3D12Heap_iface.lpVtbl = &d3d12_heap_vtbl; @@ -202,6 +279,14 @@ static HRESULT d3d12_heap_init(struct d3d12_heap *heap, if (FAILED(hr = validate_heap_desc(&heap->desc))) return hr; + memory_requirements.size = heap->desc.SizeInBytes; + memory_requirements.alignment = heap->desc.Alignment; + memory_requirements.memoryTypeBits = ~(uint32_t)0; + + if (FAILED(hr = vkd3d_allocate_device_memory(device, &heap->desc.Properties, + heap->desc.Flags, &memory_requirements, &heap->vk_memory))) + return hr; + heap->device = device; ID3D12Device_AddRef(&device->ID3D12Device_iface); @@ -433,79 +518,6 @@ HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, return hr; } -static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) -{ - VkPhysicalDeviceMemoryProperties *memory_info = &device->memory_properties; - VkMemoryPropertyFlags required_flags; - unsigned int i; - - switch (heap_properties->Type) - { - case D3D12_HEAP_TYPE_DEFAULT: - required_flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - break; - - case D3D12_HEAP_TYPE_CUSTOM: - FIXME("Custom heaps not supported yet.\n"); - /* fall-through */ - case D3D12_HEAP_TYPE_UPLOAD: - case D3D12_HEAP_TYPE_READBACK: - required_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - break; - - default: - WARN("Invalid heap type %#x.\n", heap_properties->Type); - return ~0u; - } - - for (i = 0; i < memory_info->memoryTypeCount; ++i) - { - if (!(memory_type_mask & (1u << i))) - continue; - if ((memory_info->memoryTypes[i].propertyFlags & required_flags) == required_flags) - return i; - } - - return ~0u; -} - -static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const VkMemoryRequirements *memory_requirements, VkDeviceMemory *vk_memory) -{ - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - VkMemoryAllocateInfo allocate_info; - VkResult vr; - - TRACE("Memory requirements: size %#"PRIx64", alignment %#"PRIx64".\n", - memory_requirements->size, memory_requirements->alignment); - - allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; - allocate_info.pNext = NULL; - allocate_info.allocationSize = memory_requirements->size; - allocate_info.memoryTypeIndex = vkd3d_select_memory_type(device, - memory_requirements->memoryTypeBits, heap_properties, heap_flags); - - if (allocate_info.memoryTypeIndex == ~0u) - { - FIXME("Failed to find suitable memory type (allowed types %#x).\n", memory_requirements->memoryTypeBits); - *vk_memory = VK_NULL_HANDLE; - return E_FAIL; - } - - TRACE("Allocating memory type %u.\n", allocate_info.memoryTypeIndex); - - if ((vr = VK_CALL(vkAllocateMemory(device->vk_device, &allocate_info, NULL, vk_memory))) < 0) - { - WARN("Failed to allocate device memory, vr %d.\n", vr); - *vk_memory = VK_NULL_HANDLE; - return hresult_from_vk_result(vr); - } - - return S_OK; -} - HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, VkDeviceMemory *vk_memory) diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 189ee43..4865671 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -190,6 +190,8 @@ struct d3d12_heap D3D12_HEAP_DESC desc; + VkDeviceMemory vk_memory; + struct d3d12_device *device; };

1 0

Józef Kucia : vkd3d: Implement d3d12_device_GetResourceAllocationInfo() for textures.
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: 0014c4fbf97224690b4793d5723d9616d545cbc0 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=0014c4fbf97224690b4793d… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:02 2018 +0200 vkd3d: Implement d3d12_device_GetResourceAllocationInfo() for textures. In Vulkan, we have to create an image to get its memory requirements. It would be very helpful if we could get the memory requirements without creating a resource. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- libs/vkd3d/device.c | 38 ++++++++++++++++++++++++++++++++++---- libs/vkd3d/resource.c | 24 ++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 16 +++++++++------- 3 files changed, 67 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 54196ac..8cc6142 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2025,7 +2025,10 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour ID3D12Device *iface, D3D12_RESOURCE_ALLOCATION_INFO *info, UINT visible_mask, UINT count, const D3D12_RESOURCE_DESC *resource_descs) { + UINT64 default_alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; + struct d3d12_device *device = impl_from_ID3D12Device(iface); const D3D12_RESOURCE_DESC *desc; + bool valid = true; TRACE("iface %p, info %p, visible_mask 0x%08x, count %u, resource_descs %p.\n", iface, info, visible_mask, count, resource_descs); @@ -2042,22 +2045,49 @@ static D3D12_RESOURCE_ALLOCATION_INFO * STDMETHODCALLTYPE d3d12_device_GetResour } desc = &resource_descs[0]; + + if (FAILED(d3d12_resource_validate_desc(desc))) + { + WARN("Invalid resource desc.\n"); + valid = false; + } + if (desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) { - info->SizeInBytes = align(desc->Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT); + info->SizeInBytes = desc->Width; info->Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; } else { - FIXME("Unhandled dimension %#x.\n", desc->Dimension); + if (desc->SampleDesc.Count != 1) + default_alignment = D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT; + + if (valid && FAILED(vkd3d_get_image_allocation_info(device, desc, info))) + { + WARN("Failed to get allocation info for texture.\n"); + valid = false; + } } - if (FAILED(d3d12_resource_validate_desc(desc))) + if (desc->Alignment % info->Alignment) + { + WARN("Invalid resource alignment %#"PRIx64" (required %#"PRIx64").\n", + desc->Alignment, info->Alignment); + valid = false; + } + + if (valid) + { + info->SizeInBytes = align(info->SizeInBytes, info->Alignment); + } + else { - WARN("Invalid resource desc.\n"); info->SizeInBytes = ~(UINT64)0; + info->Alignment = default_alignment; } + TRACE("Size %#"PRIx64", alignment %#"PRIx64".\n", info->SizeInBytes, info->Alignment); + return info; } diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index d5690de..82ff701 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -409,6 +409,30 @@ static HRESULT vkd3d_create_image(struct d3d12_device *device, return S_OK; } +HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) +{ + static const D3D12_HEAP_PROPERTIES heap_properties = {D3D12_HEAP_TYPE_DEFAULT}; + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkMemoryRequirements requirements; + VkImage vk_image; + HRESULT hr; + + assert(desc->Dimension != D3D12_RESOURCE_DIMENSION_BUFFER); + + /* XXX: We have to create an image to get its memory requirements. */ + if (SUCCEEDED(hr = vkd3d_create_image(device, &heap_properties, 0, desc, &vk_image))) + { + VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &requirements)); + VK_CALL(vkDestroyImage(device->vk_device, vk_image, NULL)); + + allocation_info->SizeInBytes = requirements.size; + allocation_info->Alignment = requirements.alignment; + } + + return hr; +} + static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index c4d6dd5..189ee43 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -251,6 +251,15 @@ HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_h const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN; +HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN; +HRESULT vkd3d_create_buffer(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; +HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) DECLSPEC_HIDDEN; + struct vkd3d_view { LONG refcount; @@ -773,13 +782,6 @@ VkPipeline d3d12_device_find_cached_pipeline(struct d3d12_device *device, bool d3d12_device_put_pipeline_to_cache(struct d3d12_device *device, const struct vkd3d_pipeline_key *key, VkPipeline vk_pipeline, struct list *list) DECLSPEC_HIDDEN; -HRESULT vkd3d_create_buffer(struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; -HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN; - /* utils */ struct vkd3d_format {

1 0

Józef Kucia : vkd3d: Pass D3D12_RESOURCE_DESC and VkImage to vkd3d_create_image().
by Alexandre Julliard 26 Sep '18

26 Sep '18

Module: vkd3d Branch: master Commit: ded908c51591cd44e40e23d3955aa8e38fc92bc0 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=ded908c51591cd44e40e23d… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Tue Sep 25 14:13:01 2018 +0200 vkd3d: Pass D3D12_RESOURCE_DESC and VkImage to vkd3d_create_image(). For consistency with vkd3d_create_buffer(). Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- libs/vkd3d/resource.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 1580450..d5690de 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -321,17 +321,15 @@ static unsigned int max_miplevel_count(const D3D12_RESOURCE_DESC *desc) return vkd3d_log2i(size) + 1; } -static HRESULT vkd3d_create_image(struct d3d12_resource *resource, struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) +static HRESULT vkd3d_create_image(struct d3d12_device *device, + const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, + const D3D12_RESOURCE_DESC *desc, VkImage *vk_image) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; const struct vkd3d_format *format; - const D3D12_RESOURCE_DESC *desc; VkImageCreateInfo image_info; VkResult vr; - desc = &resource->desc; - if (!(format = vkd3d_format_from_d3d12_resource_desc(desc, 0))) { WARN("Invalid DXGI format %#x.\n", desc->Format); @@ -402,7 +400,7 @@ static HRESULT vkd3d_create_image(struct d3d12_resource *resource, struct d3d12_ image_info.initialLayout = is_cpu_accessible_heap(heap_properties) ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED; - if ((vr = VK_CALL(vkCreateImage(device->vk_device, &image_info, NULL, &resource->u.vk_image))) < 0) + if ((vr = VK_CALL(vkCreateImage(device->vk_device, &image_info, NULL, vk_image))) < 0) { WARN("Failed to create Vulkan image, vr %d.\n", vr); return hresult_from_vk_result(vr); @@ -976,7 +974,8 @@ static HRESULT d3d12_resource_init(struct d3d12_resource *resource, struct d3d12 if (!resource->desc.MipLevels) resource->desc.MipLevels = max_miplevel_count(desc); resource->flags |= VKD3D_RESOURCE_INITIAL_STATE_TRANSITION; - if (FAILED(hr = vkd3d_create_image(resource, device, heap_properties, heap_flags))) + if (FAILED(hr = vkd3d_create_image(device, heap_properties, heap_flags, + &resource->desc, &resource->u.vk_image))) return hr; break;

1 0

← Newer
1
...
7
8
9
10
11
12
13
...
67
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-commits September 2018