From 8826f3c5bca19f07135f2edac3ae7e693e4d1da0 Mon Sep 17 00:00:00 2001 From: Philip Rebohle Date: Thu, 4 Feb 2021 17:34:22 +0100 Subject: [PATCH] vkd3d: Remove d3d12_heap and old resource creation functions. Signed-off-by: Philip Rebohle --- libs/vkd3d/resource.c | 857 ------------------------------------- libs/vkd3d/vkd3d_private.h | 36 -- 2 files changed, 893 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 8829ed0f..3d8c4a58 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -207,33 +207,6 @@ static HRESULT vkd3d_import_host_memory(struct d3d12_device *device, type_mask, &import_info, vk_memory, vk_memory_type); } -static HRESULT vkd3d_allocate_device_memory(struct d3d12_device *device, - const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - VkDeviceSize size, VkDeviceMemory *vk_memory, uint32_t *vk_memory_type) -{ - VkMemoryAllocateFlagsInfo flags_info; - VkMemoryPropertyFlags type_flags; - HRESULT hr; - - flags_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; - flags_info.pNext = NULL; - flags_info.flags = 0; - - if (!(heap_flags & D3D12_HEAP_FLAG_DENY_BUFFERS) && - device->device_info.buffer_device_address_features.bufferDeviceAddress) - flags_info.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR; - - if (FAILED(hr = vkd3d_select_memory_flags(device, heap_properties, &type_flags))) - return hr; - - if (FAILED(hr = vkd3d_allocate_memory(device, size, type_flags, - vkd3d_select_memory_types(device, heap_properties, heap_flags), - &flags_info, vk_memory, vk_memory_type))) - return hr; - - return S_OK; -} - HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, void *host_memory, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size) @@ -397,525 +370,6 @@ static HRESULT vkd3d_allocate_image_memory(struct d3d12_device *device, VkImage return S_OK; } -/* ID3D12Heap */ -static inline struct d3d12_heap *impl_from_ID3D12Heap(d3d12_heap_iface *iface) -{ - return CONTAINING_RECORD(iface, struct d3d12_heap, ID3D12Heap_iface); -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_QueryInterface(d3d12_heap_iface *iface, - REFIID iid, void **object) -{ - TRACE("iface %p, iid %s, object %p.\n", iface, debugstr_guid(iid), object); - - if (IsEqualGUID(iid, &IID_ID3D12Heap) - || IsEqualGUID(iid, &IID_ID3D12Heap1) - || IsEqualGUID(iid, &IID_ID3D12Pageable) - || IsEqualGUID(iid, &IID_ID3D12DeviceChild) - || IsEqualGUID(iid, &IID_ID3D12Object) - || IsEqualGUID(iid, &IID_IUnknown)) - { - ID3D12Heap_AddRef(iface); - *object = iface; - return S_OK; - } - - WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid)); - - *object = NULL; - return E_NOINTERFACE; -} - -static ULONG STDMETHODCALLTYPE d3d12_heap_AddRef(d3d12_heap_iface *iface) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - ULONG refcount = InterlockedIncrement(&heap->refcount); - - TRACE("%p increasing refcount to %u.\n", heap, refcount); - - assert(!heap->is_private); - - return refcount; -} - -static ULONG d3d12_resource_decref(struct d3d12_resource *resource); - -static void d3d12_heap_cleanup(struct d3d12_heap *heap) -{ - struct d3d12_device *device = heap->device; - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - - if (heap->buffer_resource) - d3d12_resource_decref(heap->buffer_resource); - - VK_CALL(vkFreeMemory(device->vk_device, heap->vk_memory, NULL)); - - if (heap->is_private) - device = NULL; - - if (device) - d3d12_device_release(device); -} - -static void d3d12_heap_destroy(struct d3d12_heap *heap) -{ - TRACE("Destroying heap %p.\n", heap); - - d3d12_heap_cleanup(heap); - vkd3d_private_store_destroy(&heap->private_store); - vkd3d_free(heap); -} - -static ULONG STDMETHODCALLTYPE d3d12_heap_Release(d3d12_heap_iface *iface) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - ULONG refcount = InterlockedDecrement(&heap->refcount); - - TRACE("%p decreasing refcount to %u.\n", heap, refcount); - - if (!refcount) - d3d12_heap_destroy(heap); - - return refcount; -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_GetPrivateData(d3d12_heap_iface *iface, - REFGUID guid, UINT *data_size, void *data) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_get_private_data(&heap->private_store, guid, data_size, data); -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_SetPrivateData(d3d12_heap_iface *iface, - REFGUID guid, UINT data_size, const void *data) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data); - - return vkd3d_set_private_data(&heap->private_store, guid, data_size, data); -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_SetPrivateDataInterface(d3d12_heap_iface *iface, - REFGUID guid, const IUnknown *data) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data); - - return vkd3d_set_private_data_interface(&heap->private_store, guid, data); -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_SetName(d3d12_heap_iface *iface, const WCHAR *name) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, name %s.\n", iface, debugstr_w(name)); - - return vkd3d_set_vk_object_name(heap->device, (uint64_t)heap->vk_memory, - VK_OBJECT_TYPE_DEVICE_MEMORY, name); -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_GetDevice(d3d12_heap_iface *iface, REFIID iid, void **device) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, iid %s, device %p.\n", iface, debugstr_guid(iid), device); - - return d3d12_device_query_interface(heap->device, iid, device); -} - -static D3D12_HEAP_DESC * STDMETHODCALLTYPE d3d12_heap_GetDesc(d3d12_heap_iface *iface, - D3D12_HEAP_DESC *desc) -{ - struct d3d12_heap *heap = impl_from_ID3D12Heap(iface); - - TRACE("iface %p, desc %p.\n", iface, desc); - - *desc = heap->desc; - return desc; -} - -static HRESULT STDMETHODCALLTYPE d3d12_heap_GetProtectedResourceSession(d3d12_heap_iface *iface, - REFIID iid, void **protected_session) -{ - FIXME("iface %p, iid %s, protected_session %p stub!", iface, debugstr_guid(iid), protected_session); - - return E_NOTIMPL; -} - -static CONST_VTBL struct ID3D12Heap1Vtbl d3d12_heap_vtbl = -{ - /* IUnknown methods */ - d3d12_heap_QueryInterface, - d3d12_heap_AddRef, - d3d12_heap_Release, - /* ID3D12Object methods */ - d3d12_heap_GetPrivateData, - d3d12_heap_SetPrivateData, - d3d12_heap_SetPrivateDataInterface, - d3d12_heap_SetName, - /* ID3D12DeviceChild methods */ - d3d12_heap_GetDevice, - /* ID3D12Heap methods */ - d3d12_heap_GetDesc, - /* ID3D12Heap1 methods */ - d3d12_heap_GetProtectedResourceSession, -}; - -static struct d3d12_heap *unsafe_impl_from_ID3D12Heap1(ID3D12Heap1 *iface) -{ - if (!iface) - return NULL; - assert(iface->lpVtbl == &d3d12_heap_vtbl); - return impl_from_ID3D12Heap(iface); -} - -struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) -{ - return unsafe_impl_from_ID3D12Heap1((ID3D12Heap1 *)iface); -} - -static HRESULT validate_heap_desc(const D3D12_HEAP_DESC *desc, const struct d3d12_resource *resource) -{ - if (!resource && !desc->SizeInBytes) - { - WARN("Invalid size %"PRIu64".\n", desc->SizeInBytes); - return E_INVALIDARG; - } - - if (desc->Alignment != D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT - && desc->Alignment != D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT) - { - WARN("Invalid alignment %"PRIu64".\n", desc->Alignment); - return E_INVALIDARG; - } - - if (!resource && desc->Flags & D3D12_HEAP_FLAG_ALLOW_DISPLAY) - { - WARN("D3D12_HEAP_FLAG_ALLOW_DISPLAY is only for committed resources.\n"); - return E_INVALIDARG; - } - - return S_OK; -} - -static HRESULT validate_placed_resource_heap(struct d3d12_heap *heap, const D3D12_RESOURCE_DESC *resource_desc) -{ - D3D12_HEAP_FLAGS deny_flag; - - if (resource_desc->Dimension == D3D12_RESOURCE_DIMENSION_BUFFER) - deny_flag = D3D12_HEAP_FLAG_DENY_BUFFERS; - else if (resource_desc->Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) - deny_flag = D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES; - else - deny_flag = D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES; - - if (heap->desc.Flags & deny_flag) - { - WARN("Cannot create placed resource on heap that denies resource category %#x.\n", deny_flag); - return E_INVALIDARG; - } - - if ((heap->desc.Flags & D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER) && - !(resource_desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER)) - { - ERR("Must declare ALLOW_CROSS_ADAPTER resource flag when heap is cross adapter.\n"); - return E_INVALIDARG; - } - - return S_OK; -} - -static HRESULT d3d12_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, - const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed, - struct d3d12_resource **resource); - -static HRESULT d3d12_heap_init_omnipotent_buffer(struct d3d12_heap *heap, struct d3d12_device *device, - const D3D12_HEAP_DESC *desc) -{ - D3D12_RESOURCE_STATES initial_resource_state; - D3D12_RESOURCE_DESC resource_desc; - HRESULT hr; - - /* Create a single omnipotent buffer which fills the entire heap. - * Whenever we place buffer resources on this heap, we'll just offset this VkBuffer. - * This allows us to keep VA space somewhat sane, and keeps number of (limited) VA allocations down. - * One possible downside is that the buffer might be slightly slower to access, - * but D3D12 has very lenient usage flags for buffers. */ - - memset(&resource_desc, 0, sizeof(resource_desc)); - resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; - resource_desc.Width = desc->SizeInBytes; - resource_desc.Height = 1; - resource_desc.DepthOrArraySize = 1; - resource_desc.MipLevels = 1; - resource_desc.SampleDesc.Count = 1; - resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; - if (heap->desc.Flags & D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER) - resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER; - - switch (desc->Properties.Type) - { - case D3D12_HEAP_TYPE_UPLOAD: - initial_resource_state = D3D12_RESOURCE_STATE_GENERIC_READ; - break; - - case D3D12_HEAP_TYPE_READBACK: - initial_resource_state = D3D12_RESOURCE_STATE_COPY_DEST; - break; - - default: - /* Upload and readback heaps do not allow UAV access, only enable this flag for other heaps. */ - resource_desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - initial_resource_state = D3D12_RESOURCE_STATE_COMMON; - break; - } - - if (FAILED(hr = d3d12_resource_create(device, &desc->Properties, desc->Flags, - &resource_desc, initial_resource_state, - NULL, false, &heap->buffer_resource))) - return hr; - - /* This internal resource should not own a reference on the device. - * d3d12_resource_create takes a reference on the device. */ - d3d12_device_release(device); - return S_OK; -} - -static HRESULT d3d12_heap_allocate_storage(struct d3d12_heap *heap, - struct d3d12_device *device, const struct d3d12_resource *resource, void *host_memory) -{ - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - const VkMemoryType *memory_type; - VkDeviceSize vk_memory_size; - VkResult vr; - HRESULT hr; - - if (resource) - { - if (d3d12_resource_is_buffer(resource)) - { - hr = vkd3d_allocate_buffer_memory(device, resource->vk_buffer, NULL, - &heap->desc.Properties, heap->desc.Flags | D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS, - &heap->vk_memory, &heap->vk_memory_type, &vk_memory_size); - } - else - { - hr = vkd3d_allocate_image_memory(device, resource->vk_image, - &heap->desc.Properties, heap->desc.Flags, - &heap->vk_memory, &heap->vk_memory_type, &vk_memory_size); - } - - heap->desc.SizeInBytes = vk_memory_size; - } - else if (heap->buffer_resource) - { - hr = vkd3d_allocate_buffer_memory(device, heap->buffer_resource->vk_buffer, host_memory, - &heap->desc.Properties, heap->desc.Flags, - &heap->vk_memory, &heap->vk_memory_type, &vk_memory_size); - } - else - { - hr = vkd3d_allocate_device_memory(device, &heap->desc.Properties, - heap->desc.Flags, heap->desc.SizeInBytes, &heap->vk_memory, - &heap->vk_memory_type); - } - - if (FAILED(hr)) - return hr; - - memory_type = &device->memory_properties.memoryTypes[heap->vk_memory_type]; - - if (memory_type->propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) - { - if ((vr = VK_CALL(vkMapMemory(device->vk_device, - heap->vk_memory, 0, VK_WHOLE_SIZE, 0, &heap->map_ptr))) < 0) - { - ERR("Failed to map memory, vr %d.\n", vr); - return hresult_from_vk_result(hr); - } - - if ((heap->desc.Flags & D3D12_HEAP_FLAG_SHARED) == 0) - { - /* Zero private host-visible memory */ - memset(heap->map_ptr, 0, heap->desc.SizeInBytes); - } - - if (!(memory_type->propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) - { - VkMappedMemoryRange mapped_range; - mapped_range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; - mapped_range.pNext = NULL; - mapped_range.memory = heap->vk_memory; - mapped_range.offset = 0; - mapped_range.size = VK_WHOLE_SIZE; - - VK_CALL(vkFlushMappedMemoryRanges(device->vk_device, 1, &mapped_range)); - } - } - - return S_OK; -} - -static HRESULT d3d12_heap_init(struct d3d12_heap *heap, - struct d3d12_device *device, const D3D12_HEAP_DESC *desc, const struct d3d12_resource *resource) -{ - bool buffers_allowed; - HRESULT hr; - - memset(heap, 0, sizeof(*heap)); - heap->ID3D12Heap_iface.lpVtbl = &d3d12_heap_vtbl; - heap->refcount = 1; - heap->device = device; - - heap->is_private = !!resource; - - heap->desc = *desc; - - heap->map_ptr = NULL; - heap->buffer_resource = NULL; - - if (!heap->is_private) - d3d12_device_add_ref(heap->device); - - if (!heap->desc.Properties.CreationNodeMask) - heap->desc.Properties.CreationNodeMask = 1; - if (!heap->desc.Properties.VisibleNodeMask) - heap->desc.Properties.VisibleNodeMask = 1; - - debug_ignored_node_mask(heap->desc.Properties.CreationNodeMask); - debug_ignored_node_mask(heap->desc.Properties.VisibleNodeMask); - - if (!heap->desc.Alignment) - heap->desc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; - - if (FAILED(hr = validate_heap_desc(&heap->desc, resource))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - buffers_allowed = !(heap->desc.Flags & D3D12_HEAP_FLAG_DENY_BUFFERS); - if (buffers_allowed && !resource) - { - if (FAILED(hr = d3d12_heap_init_omnipotent_buffer(heap, device, desc))) - { - d3d12_heap_cleanup(heap); - return hr; - } - } - - if (FAILED(hr = vkd3d_private_store_init(&heap->private_store))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - if (FAILED(hr = d3d12_heap_allocate_storage(heap, device, resource, NULL))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - return S_OK; -} - -static HRESULT d3d12_heap_init_from_host_pointer(struct d3d12_heap *heap, - struct d3d12_device *device, void *address, size_t size) -{ - HRESULT hr; - - if (!device->vk_info.EXT_external_memory_host) - { - WARN("VK_EXT_external_memory_host is not supported. Falling back to a private allocation. This will likely break debug code.\n"); - address = NULL; - } - - memset(heap, 0, sizeof(*heap)); - heap->ID3D12Heap_iface.lpVtbl = &d3d12_heap_vtbl; - heap->refcount = 1; - heap->device = device; - - heap->desc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT; - heap->desc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS | - (address ? (D3D12_HEAP_FLAG_SHARED | D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER) : 0); - heap->desc.Properties.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_WRITE_BACK; - heap->desc.Properties.MemoryPoolPreference = D3D12_MEMORY_POOL_L0; - heap->desc.Properties.Type = D3D12_HEAP_TYPE_CUSTOM; - heap->desc.Properties.CreationNodeMask = 1; - heap->desc.Properties.VisibleNodeMask = 1; - heap->desc.SizeInBytes = size; - - d3d12_device_add_ref(heap->device); - - if (FAILED(hr = d3d12_heap_init_omnipotent_buffer(heap, device, &heap->desc))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - if (FAILED(hr = vkd3d_private_store_init(&heap->private_store))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - if (FAILED(hr = d3d12_heap_allocate_storage(heap, device, NULL, address))) - { - d3d12_heap_cleanup(heap); - return hr; - } - - return S_OK; -} - -HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, - const struct d3d12_resource *resource, struct d3d12_heap **heap) -{ - struct d3d12_heap *object; - HRESULT hr; - - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - - if (FAILED(hr = d3d12_heap_init(object, device, desc, resource))) - { - vkd3d_free(object); - return hr; - } - - TRACE("Created %s %p.\n", object->is_private ? "private heap" : "heap", object); - - *heap = object; - - return S_OK; -} - -HRESULT d3d12_heap_create_from_host_pointer(struct d3d12_device *device, void *address, size_t size, - struct d3d12_heap **heap) -{ - struct d3d12_heap *object; - HRESULT hr; - - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - - if (FAILED(hr = d3d12_heap_init_from_host_pointer(object, device, address, size))) - { - vkd3d_free(object); - return hr; - } - - *heap = object; - return S_OK; -} - static VkImageType vk_image_type_from_d3d12_resource_dimension(D3D12_RESOURCE_DIMENSION dimension) { switch (dimension) @@ -1980,42 +1434,6 @@ static void d3d12_resource_get_tiling(struct d3d12_device *device, struct d3d12_ static void d3d12_resource_destroy_2(struct d3d12_resource *resource, struct d3d12_device *device); -static void d3d12_resource_destroy(struct d3d12_resource *resource, struct d3d12_device *device) -{ - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - - vkd3d_view_map_destroy(&resource->view_map, resource->device); - -#ifdef VKD3D_ENABLE_DESCRIPTOR_QA - vkd3d_descriptor_debug_unregister_cookie(resource->cookie); -#endif - - if (resource->flags & VKD3D_RESOURCE_EXTERNAL) - return; - - if (resource->flags & VKD3D_RESOURCE_SPARSE) - { - VK_CALL(vkFreeMemory(device->vk_device, resource->sparse.vk_metadata_memory, NULL)); - - vkd3d_free(resource->sparse.tiles); - vkd3d_free(resource->sparse.tilings); - } - - if (!(resource->flags & VKD3D_RESOURCE_PLACED_BUFFER)) - { - if (resource->gpu_address) - vkd3d_gpu_va_allocator_free(&device->gpu_va_allocator, resource->gpu_address); - - if (d3d12_resource_is_buffer(resource)) - VK_CALL(vkDestroyBuffer(device->vk_device, resource->vk_buffer, NULL)); - else - VK_CALL(vkDestroyImage(device->vk_device, resource->vk_image, NULL)); - } - - if (resource->flags & VKD3D_RESOURCE_DEDICATED_HEAP) - d3d12_heap_destroy(resource->heap); -} - static ULONG d3d12_resource_incref(struct d3d12_resource *resource) { ULONG refcount = InterlockedIncrement(&resource->internal_refcount); @@ -3068,107 +2486,6 @@ static HRESULT d3d12_resource_init_sparse_info(struct d3d12_resource *resource, return S_OK; } -static HRESULT d3d12_resource_init(struct d3d12_resource *resource, 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, - const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed) -{ - HRESULT hr; - - if (FAILED(hr = d3d12_resource_validate_create_info(desc, - heap_properties, initial_state, optimized_clear_value, device))) - return hr; - - resource->ID3D12Resource_iface.lpVtbl = &d3d12_resource_vtbl; - resource->refcount = 1; - resource->internal_refcount = 1; - - resource->desc = *desc; - resource->cookie = vkd3d_allocate_cookie(); - -#ifdef VKD3D_ENABLE_DESCRIPTOR_QA - vkd3d_descriptor_debug_register_resource_cookie(resource->cookie, desc); -#endif - - if (FAILED(hr = vkd3d_view_map_init(&resource->view_map))) - return hr; - -#ifdef VKD3D_ENABLE_DESCRIPTOR_QA - resource->view_map.resource_cookie = resource->cookie; -#endif - - resource->gpu_address = 0; - resource->flags = 0; - resource->initial_layout_transition = 0; - resource->common_layout = VK_IMAGE_LAYOUT_UNDEFINED; - - if (placed && d3d12_resource_is_buffer(resource)) - resource->flags |= VKD3D_RESOURCE_PLACED_BUFFER; - - if (!heap_properties) - resource->flags |= VKD3D_RESOURCE_SPARSE; - - resource->format = vkd3d_format_from_d3d12_resource_desc(device, desc, 0); - - switch (desc->Dimension) - { - case D3D12_RESOURCE_DIMENSION_BUFFER: - /* We'll inherit a VkBuffer reference from the heap with an implied offset. */ - if (placed) - { - resource->vk_buffer = VK_NULL_HANDLE; - break; - } - - if (FAILED(hr = vkd3d_create_buffer(device, heap_properties, heap_flags, - &resource->desc, &resource->vk_buffer))) - return hr; - if (!(resource->gpu_address = vkd3d_gpu_va_allocator_allocate(&device->gpu_va_allocator, - desc->Alignment ? desc->Alignment : D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT, - desc->Width, resource))) - { - ERR("Failed to allocate GPU VA.\n"); - d3d12_resource_destroy(resource, device); - return E_OUTOFMEMORY; - } - break; - - case D3D12_RESOURCE_DIMENSION_TEXTURE1D: - case D3D12_RESOURCE_DIMENSION_TEXTURE2D: - case D3D12_RESOURCE_DIMENSION_TEXTURE3D: - if (!resource->desc.MipLevels) - resource->desc.MipLevels = max_miplevel_count(desc); - resource->initial_layout_transition = 1; - if (FAILED(hr = vkd3d_create_image(device, heap_properties, heap_flags, - &resource->desc, resource, &resource->vk_image))) - return hr; - break; - - default: - WARN("Invalid resource dimension %#x.\n", resource->desc.Dimension); - return E_INVALIDARG; - } - - if (FAILED(hr = d3d12_resource_init_sparse_info(resource, device, &resource->sparse))) - { - d3d12_resource_destroy(resource, device); - return hr; - } - - resource->heap = NULL; - resource->heap_offset = 0; - - if (FAILED(hr = vkd3d_private_store_init(&resource->private_store))) - { - d3d12_resource_destroy(resource, device); - return hr; - } - - d3d12_device_add_ref(resource->device = device); - - return S_OK; -} - static void d3d12_resource_destroy_2(struct d3d12_resource *resource, struct d3d12_device *device) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; @@ -3510,180 +2827,6 @@ fail: return hr; } -static HRESULT d3d12_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, - const D3D12_CLEAR_VALUE *optimized_clear_value, bool placed, struct d3d12_resource **resource) -{ - struct d3d12_resource *object; - HRESULT hr; - - if (!(object = vkd3d_malloc(sizeof(*object)))) - return E_OUTOFMEMORY; - - if (FAILED(hr = d3d12_resource_init(object, device, heap_properties, heap_flags, - desc, initial_state, optimized_clear_value, placed))) - { - vkd3d_free(object); - return hr; - } - - *resource = object; - - 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) -{ - D3D12_HEAP_DESC heap_desc; - HRESULT hr; - - heap_desc.SizeInBytes = 0; - heap_desc.Properties = *heap_properties; - heap_desc.Alignment = 0; - heap_desc.Flags = heap_flags; - if (SUCCEEDED(hr = d3d12_heap_create(device, &heap_desc, resource, &resource->heap))) - resource->flags |= VKD3D_RESOURCE_DEDICATED_HEAP; - return hr; -} - -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, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) -{ - struct d3d12_resource *object; - HRESULT hr; - - if (!heap_properties) - { - WARN("Heap properties are NULL.\n"); - return E_INVALIDARG; - } - - if (FAILED(hr = d3d12_resource_create(device, heap_properties, heap_flags, - desc, initial_state, optimized_clear_value, false, &object))) - return hr; - - if (FAILED(hr = vkd3d_allocate_resource_memory(device, object, heap_properties, heap_flags))) - { - 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_t heap_offset) -{ - const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - VkDevice vk_device = device->vk_device; - VkMemoryRequirements requirements; - VkResult vr; - - if (resource->flags & VKD3D_RESOURCE_PLACED_BUFFER) - { - /* Just inherit the buffer from the heap. */ - resource->vk_buffer = heap->buffer_resource->vk_buffer; - resource->heap = heap; - resource->heap_offset = heap_offset; - resource->gpu_address = heap->buffer_resource->gpu_address + heap_offset; - return S_OK; - } - - if (d3d12_resource_is_buffer(resource)) - VK_CALL(vkGetBufferMemoryRequirements(vk_device, resource->vk_buffer, &requirements)); - else - VK_CALL(vkGetImageMemoryRequirements(vk_device, resource->vk_image, &requirements)); - - if (heap_offset % requirements.alignment) - { - FIXME("Invalid heap offset %#"PRIx64" (alignment %#"PRIx64").\n", - heap_offset, requirements.alignment); - goto allocate_memory; - } - - if (!(requirements.memoryTypeBits & (1u << heap->vk_memory_type))) - { - FIXME("Memory type %u cannot be bound to resource %p (allowed types %#x).\n", - heap->vk_memory_type, resource, requirements.memoryTypeBits); - goto allocate_memory; - } - - if (d3d12_resource_is_buffer(resource)) - vr = VK_CALL(vkBindBufferMemory(vk_device, resource->vk_buffer, heap->vk_memory, heap_offset)); - else - vr = VK_CALL(vkBindImageMemory(vk_device, resource->vk_image, heap->vk_memory, heap_offset)); - - if (vr == VK_SUCCESS) - { - resource->heap = heap; - resource->heap_offset = heap_offset; - } - else - { - WARN("Failed to bind memory, vr %d.\n", vr); - } - - return hresult_from_vk_result(vr); - -allocate_memory: - FIXME("Allocating device memory.\n"); - return vkd3d_allocate_resource_memory(device, resource, &heap->desc.Properties, heap->desc.Flags); -} - -HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) -{ - struct d3d12_resource *object; - HRESULT hr; - - if (FAILED(hr = validate_placed_resource_heap(heap, desc))) - return hr; - - if (FAILED(hr = d3d12_resource_create(device, &heap->desc.Properties, heap->desc.Flags, - desc, initial_state, optimized_clear_value, true, &object))) - return hr; - - 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 d3d12_reserved_resource_create(struct d3d12_device *device, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) -{ - struct d3d12_resource *object; - HRESULT hr; - - if (FAILED(hr = d3d12_resource_create(device, NULL, 0, - desc, initial_state, optimized_clear_value, false, &object))) - return hr; - - TRACE("Created reserved resource %p.\n", object); - - *resource = object; - - return S_OK; -} - VKD3D_EXPORT HRESULT vkd3d_create_image_resource(ID3D12Device *device, const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index f846d9c8..1d80a2d4 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -618,31 +618,6 @@ HRESULT vkd3d_memory_allocator_flush_clears(struct vkd3d_memory_allocator *alloc /* ID3D12Heap */ typedef ID3D12Heap1 d3d12_heap_iface; -struct d3d12_heap -{ - d3d12_heap_iface ID3D12Heap_iface; - LONG refcount; - - bool is_private; - D3D12_HEAP_DESC desc; - - VkDeviceMemory vk_memory; - void *map_ptr; - uint32_t vk_memory_type; - - struct d3d12_resource *buffer_resource; - struct d3d12_device *device; - - struct vkd3d_private_store private_store; -}; - -HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, - const struct d3d12_resource *resource, struct d3d12_heap **heap); -HRESULT d3d12_heap_create_from_host_pointer(struct d3d12_device *device, void *addr, size_t size, - struct d3d12_heap **heap); -bool d3d12_heap_needs_host_barrier_for_write(struct d3d12_heap *heap); -struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface); - struct d3d12_heap_2 { d3d12_heap_iface ID3D12Heap_iface; @@ -740,7 +715,6 @@ struct d3d12_resource VkImage vk_image; }; - struct d3d12_heap *heap; struct d3d12_heap_2 *heap_2; uint64_t heap_offset; @@ -781,16 +755,6 @@ 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); VkImageSubresource d3d12_resource_get_vk_subresource(const struct d3d12_resource *resource, uint32_t subresource_idx, bool all_aspects); -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, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); -HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); -HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); HRESULT d3d12_resource_create_committed_2(struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource);