vkd3d_private.h File Reference

#include "vkd3d_common.h"
#include "vkd3d_blob.h"
#include "vkd3d_memory.h"
#include "vkd3d_utf8.h"
#include "wine/list.h"
#include "wine/rbtree.h"
#include "vkd3d.h"
#include "vkd3d_shader.h"
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include "vulkan_procs.h"

Include dependency graph for vkd3d_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	vkd3d_vk_global_procs
struct	vkd3d_vk_instance_procs
struct	vkd3d_vk_device_procs
struct	vkd3d_device_descriptor_limits
struct	vkd3d_vulkan_info
struct	vkd3d_instance
union	vkd3d_thread_handle
struct	vkd3d_waiting_fence
struct	vkd3d_fence_worker
struct	vkd3d_gpu_va_allocation
struct	vkd3d_gpu_va_slab
struct	vkd3d_gpu_va_allocator
struct	vkd3d_render_pass_key
struct	vkd3d_render_pass_cache
struct	vkd3d_private_store
struct	vkd3d_private_data
struct	vkd3d_signaled_semaphore
struct	d3d12_fence
struct	d3d12_fence::vkd3d_waiting_event
struct	d3d12_heap
struct	vkd3d_tiled_region_extent
struct	vkd3d_subresource_tile_info
struct	d3d12_resource_tile_info
struct	d3d12_resource
struct	vkd3d_resource_allocation_info
struct	vkd3d_resource_view
struct	vkd3d_texture_view_desc
struct	vkd3d_desc_header
struct	vkd3d_view
struct	vkd3d_cbuffer_desc
struct	d3d12_desc
struct	d3d12_rtv_desc
struct	d3d12_dsv_desc
struct	vkd3d_vk_descriptor_heap_layout
struct	d3d12_descriptor_heap_vk_set
struct	d3d12_descriptor_heap
struct	d3d12_query_heap
struct	d3d12_root_descriptor_table_range
struct	d3d12_root_descriptor_table
struct	d3d12_root_constant
struct	d3d12_root_descriptor
struct	d3d12_root_parameter
struct	d3d12_descriptor_set_layout
struct	d3d12_root_signature
struct	d3d12_graphics_pipeline_state
struct	d3d12_compute_pipeline_state
struct	d3d12_pipeline_uav_counter_state
struct	d3d12_pipeline_state
struct	d3d12_pipeline_state_desc
struct	vkd3d_buffer
struct	d3d12_command_allocator
struct	vkd3d_push_descriptor
struct	vkd3d_pipeline_bindings
struct	d3d12_command_list
struct	vkd3d_queue
struct	vkd3d_cs_wait
struct	vkd3d_cs_signal
struct	vkd3d_cs_execute
struct	vkd3d_cs_update_mappings
struct	vkd3d_cs_copy_mappings
struct	vkd3d_cs_op_data
struct	d3d12_command_queue_op_array
struct	d3d12_command_queue
struct	d3d12_command_signature
struct	vkd3d_null_resources
struct	vkd3d_format_compatibility_list
struct	vkd3d_uav_clear_args
struct	vkd3d_uav_clear_pipelines
struct	vkd3d_uav_clear_state
struct	desc_object_cache_head
struct	vkd3d_desc_object_cache
struct	d3d12_device
struct	vkd3d_format

Macros
#define	WIDL_C_INLINE_WRAPPERS
#define	COBJMACROS
#define	NONAMELESSUNION
#define	VK_NO_PROTOTYPES
#define	CONST_VTABLE
#define	VK_CALL(f)   (vk_procs->f)
#define	VKD3D_DESCRIPTOR_MAGIC_FREE   0x00000000u
#define	VKD3D_DESCRIPTOR_MAGIC_CBV   VKD3D_MAKE_TAG('C', 'B', 'V', 0)
#define	VKD3D_DESCRIPTOR_MAGIC_SRV   VKD3D_MAKE_TAG('S', 'R', 'V', 0)
#define	VKD3D_DESCRIPTOR_MAGIC_UAV   VKD3D_MAKE_TAG('U', 'A', 'V', 0)
#define	VKD3D_DESCRIPTOR_MAGIC_SAMPLER   VKD3D_MAKE_TAG('S', 'M', 'P', 0)
#define	VKD3D_DESCRIPTOR_MAGIC_DSV   VKD3D_MAKE_TAG('D', 'S', 'V', 0)
#define	VKD3D_DESCRIPTOR_MAGIC_RTV   VKD3D_MAKE_TAG('R', 'T', 'V', 0)
#define	VKD3D_MAX_COMPATIBLE_FORMAT_COUNT   6u
#define	VKD3D_MAX_QUEUE_FAMILY_COUNT   3u
#define	VKD3D_MAX_SHADER_EXTENSIONS   5u
#define	VKD3D_MAX_SHADER_STAGES   5u
#define	VKD3D_MAX_VK_SYNC_OBJECTS   4u
#define	VKD3D_MAX_DEVICE_BLOCKED_QUEUES   16u
#define	VKD3D_MAX_DESCRIPTOR_SETS   64u
#define	VKD3D_MAX_DESCRIPTOR_SET_SAMPLERS   2048u
#define	VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE   (16 * 1024u)
#define	DECLARE_VK_PFN(name)   PFN_##name name;
#define	VK_INSTANCE_PFN   DECLARE_VK_PFN
#define	VK_INSTANCE_EXT_PFN   DECLARE_VK_PFN
#define	VK_INSTANCE_PFN   DECLARE_VK_PFN
#define	VK_DEVICE_PFN   DECLARE_VK_PFN
#define	VK_DEVICE_EXT_PFN   DECLARE_VK_PFN
#define	VKD3D_RESOURCE_PUBLIC_FLAGS    (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION)
#define	VKD3D_RESOURCE_EXTERNAL   0x00000004
#define	VKD3D_RESOURCE_DEDICATED_HEAP   0x00000008
#define	VKD3D_RESOURCE_LINEAR_TILING   0x00000010
#define	VKD3D_DESCRIPTOR_POOL_COUNT   6

Enumerations
enum	vkd3d_config_flags { VKD3D_CONFIG_FLAG_VULKAN_DEBUG = 0x00000001 , VKD3D_CONFIG_FLAG_VIRTUAL_HEAPS = 0x00000002 }
enum	vkd3d_view_type { VKD3D_VIEW_TYPE_BUFFER , VKD3D_VIEW_TYPE_IMAGE , VKD3D_VIEW_TYPE_SAMPLER }
enum	vkd3d_vk_descriptor_set_index {   VKD3D_SET_INDEX_SAMPLER , VKD3D_SET_INDEX_UAV_COUNTER , VKD3D_SET_INDEX_MUTABLE , VKD3D_SET_INDEX_UNIFORM_BUFFER = VKD3D_SET_INDEX_MUTABLE ,   VKD3D_SET_INDEX_UNIFORM_TEXEL_BUFFER , VKD3D_SET_INDEX_SAMPLED_IMAGE , VKD3D_SET_INDEX_STORAGE_TEXEL_BUFFER , VKD3D_SET_INDEX_STORAGE_IMAGE ,   VKD3D_SET_INDEX_COUNT }
enum	vkd3d_pipeline_bind_point { VKD3D_PIPELINE_BIND_POINT_GRAPHICS = 0x0 , VKD3D_PIPELINE_BIND_POINT_COMPUTE = 0x1 , VKD3D_PIPELINE_BIND_POINT_COUNT = 0x2 }
enum	vkd3d_cs_op {   VKD3D_CS_OP_WAIT , VKD3D_CS_OP_SIGNAL , VKD3D_CS_OP_EXECUTE , VKD3D_CS_OP_UPDATE_MAPPINGS ,   VKD3D_CS_OP_COPY_MAPPINGS }
enum	vkd3d_format_type { VKD3D_FORMAT_TYPE_OTHER , VKD3D_FORMAT_TYPE_TYPELESS , VKD3D_FORMAT_TYPE_SINT , VKD3D_FORMAT_TYPE_UINT }

Functions
HRESULT	hresult_from_errno (int rc)
HRESULT	hresult_from_vk_result (VkResult vr)
HRESULT	hresult_from_vkd3d_result (int vkd3d_result)
HRESULT	vkd3d_create_thread (struct vkd3d_instance *instance, PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread)
HRESULT	vkd3d_join_thread (struct vkd3d_instance *instance, union vkd3d_thread_handle *thread)
D3D12_GPU_VIRTUAL_ADDRESS	vkd3d_gpu_va_allocator_allocate (struct vkd3d_gpu_va_allocator *allocator, size_t alignment, uint64_t size, void *ptr)
void *	vkd3d_gpu_va_allocator_dereference (struct vkd3d_gpu_va_allocator *allocator, D3D12_GPU_VIRTUAL_ADDRESS address)
void	vkd3d_gpu_va_allocator_free (struct vkd3d_gpu_va_allocator *allocator, D3D12_GPU_VIRTUAL_ADDRESS address)
void	vkd3d_render_pass_cache_cleanup (struct vkd3d_render_pass_cache *cache, struct d3d12_device *device)
HRESULT	vkd3d_render_pass_cache_find (struct vkd3d_render_pass_cache *cache, struct d3d12_device *device, const struct vkd3d_render_pass_key *key, VkRenderPass *vk_render_pass)
void	vkd3d_render_pass_cache_init (struct vkd3d_render_pass_cache *cache)
static void	vkd3d_private_data_destroy (struct vkd3d_private_data *data)
static HRESULT	vkd3d_private_store_init (struct vkd3d_private_store *store)
static void	vkd3d_private_store_destroy (struct vkd3d_private_store *store)
HRESULT	vkd3d_get_private_data (struct vkd3d_private_store *store, const GUID *tag, unsigned int *out_size, void *out)
HRESULT	vkd3d_set_private_data (struct vkd3d_private_store *store, const GUID *tag, unsigned int data_size, const void *data)
HRESULT	vkd3d_set_private_data_interface (struct vkd3d_private_store *store, const GUID *tag, const IUnknown *object)
HRESULT	d3d12_fence_create (struct d3d12_device *device, uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence)
VkResult	vkd3d_create_timeline_semaphore (const struct d3d12_device *device, uint64_t initial_value, VkSemaphore *timeline_semaphore)
HRESULT	d3d12_heap_create (struct d3d12_device *device, const D3D12_HEAP_DESC *desc, const struct d3d12_resource *resource, ID3D12ProtectedResourceSession *protected_session, struct d3d12_heap **heap)
struct d3d12_heap *	unsafe_impl_from_ID3D12Heap (ID3D12Heap *iface)
static struct d3d12_resource *	impl_from_ID3D12Resource (ID3D12Resource *iface)
static struct d3d12_resource *	impl_from_ID3D12Resource2 (ID3D12Resource2 *iface)
static bool	d3d12_resource_is_buffer (const struct d3d12_resource *resource)
static bool	d3d12_resource_is_texture (const struct d3d12_resource *resource)
bool	d3d12_resource_is_cpu_accessible (const struct d3d12_resource *resource)
HRESULT	d3d12_resource_validate_desc (const D3D12_RESOURCE_DESC1 *desc, struct d3d12_device *device)
void	d3d12_resource_get_tiling (struct d3d12_device *device, const struct d3d12_resource *resource, UINT *total_tile_count, D3D12_PACKED_MIP_INFO *packed_mip_info, D3D12_TILE_SHAPE *standard_tile_shape, UINT *sub_resource_tiling_count, UINT first_sub_resource_tiling, D3D12_SUBRESOURCE_TILING *sub_resource_tilings)
HRESULT	d3d12_committed_resource_create (struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC1 *desc, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, ID3D12ProtectedResourceSession *protected_session, struct d3d12_resource **resource)
HRESULT	d3d12_placed_resource_create (struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset, const D3D12_RESOURCE_DESC1 *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_DESC1 *desc, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource)
struct d3d12_resource *	unsafe_impl_from_ID3D12Resource (ID3D12Resource *iface)
static void	d3d12_resource_desc1_from_desc (D3D12_RESOURCE_DESC1 *desc1, const D3D12_RESOURCE_DESC *desc)
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, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size)
HRESULT	vkd3d_create_buffer (struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC1 *desc, VkBuffer *vk_buffer)
HRESULT	vkd3d_get_image_allocation_info (struct d3d12_device *device, const D3D12_RESOURCE_DESC1 *desc, struct vkd3d_resource_allocation_info *allocation_info)
bool	vkd3d_create_buffer_view (struct d3d12_device *device, uint32_t magic, VkBuffer vk_buffer, const struct vkd3d_format *format, VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view)
bool	vkd3d_create_texture_view (struct d3d12_device *device, uint32_t magic, VkImage vk_image, const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view)
void	vkd3d_view_decref (void *view, struct d3d12_device *device)
static bool	vkd3d_view_incref (void *desc)
static void *	d3d12_desc_get_object_ref (const volatile struct d3d12_desc *src, struct d3d12_device *device)
static struct d3d12_desc *	d3d12_desc_from_cpu_handle (D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle)
static struct d3d12_desc *	d3d12_desc_from_gpu_handle (D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle)
static void	d3d12_desc_copy_raw (struct d3d12_desc *dst, const struct d3d12_desc *src)
void	d3d12_desc_copy (struct d3d12_desc *dst, const struct d3d12_desc *src, struct d3d12_descriptor_heap *dst_heap, struct d3d12_device *device)
void	d3d12_desc_create_cbv (struct d3d12_desc *descriptor, struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc)
void	d3d12_desc_create_srv (struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, const D3D12_SHADER_RESOURCE_VIEW_DESC *desc)
void	d3d12_desc_create_uav (struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, struct d3d12_resource *counter_resource, const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc)
void	d3d12_desc_create_sampler (struct d3d12_desc *sampler, struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc)
void	d3d12_desc_write_atomic (struct d3d12_desc *dst, const struct d3d12_desc *src, struct d3d12_device *device)
bool	vkd3d_create_raw_buffer_view (struct d3d12_device *device, D3D12_GPU_VIRTUAL_ADDRESS gpu_address, D3D12_ROOT_PARAMETER_TYPE parameter_type, VkBufferView *vk_buffer_view)
HRESULT	vkd3d_create_static_sampler (struct d3d12_device *device, const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler)
static struct d3d12_rtv_desc *	d3d12_rtv_desc_from_cpu_handle (D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle)
void	d3d12_rtv_desc_create_rtv (struct d3d12_rtv_desc *rtv_desc, struct d3d12_device *device, struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc)
static struct d3d12_dsv_desc *	d3d12_dsv_desc_from_cpu_handle (D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle)
void	d3d12_dsv_desc_create_dsv (struct d3d12_dsv_desc *dsv_desc, struct d3d12_device *device, struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc)
static enum vkd3d_vk_descriptor_set_index	vkd3d_vk_descriptor_set_index_from_vk_descriptor_type (VkDescriptorType type)
void	d3d12_desc_flush_vk_heap_updates_locked (struct d3d12_descriptor_heap *descriptor_heap, struct d3d12_device *device)
static struct d3d12_descriptor_heap *	d3d12_desc_get_descriptor_heap (const struct d3d12_desc *descriptor)
static unsigned int	d3d12_desc_heap_range_size (const struct d3d12_desc *descriptor)
HRESULT	d3d12_descriptor_heap_create (struct d3d12_device *device, const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap)
HRESULT	d3d12_query_heap_create (struct d3d12_device *device, const D3D12_QUERY_HEAP_DESC *desc, struct d3d12_query_heap **heap)
struct d3d12_query_heap *	unsafe_impl_from_ID3D12QueryHeap (ID3D12QueryHeap *iface)
static bool	d3d12_query_heap_is_result_available (const struct d3d12_query_heap *heap, unsigned int query_index)
static void	d3d12_query_heap_mark_result_as_available (struct d3d12_query_heap *heap, unsigned int query_index)
HRESULT	d3d12_root_signature_create (struct d3d12_device *device, const void *bytecode, size_t bytecode_length, struct d3d12_root_signature **root_signature)
struct d3d12_root_signature *	unsafe_impl_from_ID3D12RootSignature (ID3D12RootSignature *iface)
int	vkd3d_parse_root_signature_v_1_0 (const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_versioned_root_signature_desc *desc)
static unsigned int	dsv_attachment_mask (const struct d3d12_graphics_pipeline_state *graphics)
static bool	d3d12_pipeline_state_is_compute (const struct d3d12_pipeline_state *state)
static bool	d3d12_pipeline_state_is_graphics (const struct d3d12_pipeline_state *state)
static bool	d3d12_pipeline_state_has_unknown_dsv_format (struct d3d12_pipeline_state *state)
HRESULT	d3d12_pipeline_state_create_compute (struct d3d12_device *device, const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state)
HRESULT	d3d12_pipeline_state_create_graphics (struct d3d12_device *device, const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state)
HRESULT	d3d12_pipeline_state_create (struct d3d12_device *device, const D3D12_PIPELINE_STATE_STREAM_DESC *desc, struct d3d12_pipeline_state **state)
VkPipeline	d3d12_pipeline_state_get_or_create_pipeline (struct d3d12_pipeline_state *state, D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format, VkRenderPass *vk_render_pass)
struct d3d12_pipeline_state *	unsafe_impl_from_ID3D12PipelineState (ID3D12PipelineState *iface)
HRESULT	d3d12_command_allocator_create (struct d3d12_device *device, D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator)
HRESULT	d3d12_command_list_create (struct d3d12_device *device, UINT node_mask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator *allocator_iface, ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list)
VkQueue	vkd3d_queue_acquire (struct vkd3d_queue *queue)
HRESULT	vkd3d_queue_create (struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue)
void	vkd3d_queue_destroy (struct vkd3d_queue *queue, struct d3d12_device *device)
void	vkd3d_queue_release (struct vkd3d_queue *queue)
HRESULT	d3d12_command_queue_create (struct d3d12_device *device, const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue)
HRESULT	d3d12_command_signature_create (struct d3d12_device *device, const D3D12_COMMAND_SIGNATURE_DESC *desc, struct d3d12_command_signature **signature)
struct d3d12_command_signature *	unsafe_impl_from_ID3D12CommandSignature (ID3D12CommandSignature *iface)
HRESULT	vkd3d_init_null_resources (struct vkd3d_null_resources *null_resources, struct d3d12_device *device)
void	vkd3d_destroy_null_resources (struct vkd3d_null_resources *null_resources, struct d3d12_device *device)
HRESULT	vkd3d_uav_clear_state_init (struct vkd3d_uav_clear_state *state, struct d3d12_device *device)
void	vkd3d_uav_clear_state_cleanup (struct vkd3d_uav_clear_state *state, struct d3d12_device *device)
HRESULT	d3d12_device_create (struct vkd3d_instance *instance, const struct vkd3d_device_create_info *create_info, struct d3d12_device **device)
struct vkd3d_queue *	d3d12_device_get_vkd3d_queue (struct d3d12_device *device, D3D12_COMMAND_LIST_TYPE type)
bool	d3d12_device_is_uma (struct d3d12_device *device, bool *coherent)
void	d3d12_device_mark_as_removed (struct d3d12_device *device, HRESULT reason, const char *message,...) VKD3D_PRINTF_FUNC(3
void struct d3d12_device *	unsafe_impl_from_ID3D12Device9 (ID3D12Device9 *iface)
HRESULT	d3d12_device_add_descriptor_heap (struct d3d12_device *device, struct d3d12_descriptor_heap *heap)
void	d3d12_device_remove_descriptor_heap (struct d3d12_device *device, struct d3d12_descriptor_heap *heap)
static HRESULT	d3d12_device_query_interface (struct d3d12_device *device, REFIID iid, void **object)
static ULONG	d3d12_device_add_ref (struct d3d12_device *device)
static ULONG	d3d12_device_release (struct d3d12_device *device)
static unsigned int	d3d12_device_get_descriptor_handle_increment_size (struct d3d12_device *device, D3D12_DESCRIPTOR_HEAP_TYPE descriptor_type)
static size_t	vkd3d_format_get_data_offset (const struct vkd3d_format *format, unsigned int row_pitch, unsigned int slice_pitch, unsigned int x, unsigned int y, unsigned int z)
static bool	vkd3d_format_is_compressed (const struct vkd3d_format *format)
void	vkd3d_format_copy_data (const struct vkd3d_format *format, const uint8_t *src, unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d)
const struct vkd3d_format *	vkd3d_get_format (const struct d3d12_device *device, DXGI_FORMAT dxgi_format, bool depth_stencil)
const struct vkd3d_format *	vkd3d_find_uint_format (const struct d3d12_device *device, DXGI_FORMAT dxgi_format)
HRESULT	vkd3d_init_format_info (struct d3d12_device *device)
void	vkd3d_cleanup_format_info (struct d3d12_device *device)
static const struct vkd3d_format *	vkd3d_format_from_d3d12_resource_desc (const struct d3d12_device *device, const D3D12_RESOURCE_DESC1 *desc, DXGI_FORMAT view_format)
static bool	d3d12_box_is_empty (const D3D12_BOX *box)
static unsigned int	d3d12_resource_desc_get_width (const D3D12_RESOURCE_DESC1 *desc, unsigned int miplevel_idx)
static unsigned int	d3d12_resource_desc_get_height (const D3D12_RESOURCE_DESC1 *desc, unsigned int miplevel_idx)
static unsigned int	d3d12_resource_desc_get_depth (const D3D12_RESOURCE_DESC1 *desc, unsigned int miplevel_idx)
static unsigned int	d3d12_resource_desc_get_layer_count (const D3D12_RESOURCE_DESC1 *desc)
static unsigned int	d3d12_resource_desc_get_sub_resource_count (const D3D12_RESOURCE_DESC1 *desc)
static unsigned int	vkd3d_compute_workgroup_count (unsigned int thread_count, unsigned int workgroup_size)
VkCompareOp	vk_compare_op_from_d3d12 (D3D12_COMPARISON_FUNC op)
VkSampleCountFlagBits	vk_samples_from_dxgi_sample_desc (const DXGI_SAMPLE_DESC *desc)
VkSampleCountFlagBits	vk_samples_from_sample_count (unsigned int sample_count)
bool	is_valid_feature_level (D3D_FEATURE_LEVEL feature_level)
bool	is_valid_resource_state (D3D12_RESOURCE_STATES state)
bool	is_write_resource_state (D3D12_RESOURCE_STATES state)
HRESULT	return_interface (void *iface, REFIID iface_iid, REFIID requested_iid, void **object)
const char *	debug_cpu_handle (D3D12_CPU_DESCRIPTOR_HANDLE handle)
const char *	debug_d3d12_box (const D3D12_BOX *box)
const char *	debug_d3d12_shader_component_mapping (unsigned int mapping)
const char *	debug_gpu_handle (D3D12_GPU_DESCRIPTOR_HANDLE handle)
const char *	debug_vk_extent_3d (VkExtent3D extent)
const char *	debug_vk_memory_heap_flags (VkMemoryHeapFlags flags)
const char *	debug_vk_memory_property_flags (VkMemoryPropertyFlags flags)
const char *	debug_vk_queue_flags (VkQueueFlags flags)
static void	debug_ignored_node_mask (unsigned int mask)
HRESULT	vkd3d_load_vk_global_procs (struct vkd3d_vk_global_procs *procs, PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr)
HRESULT	vkd3d_load_vk_instance_procs (struct vkd3d_vk_instance_procs *procs, const struct vkd3d_vk_global_procs *global_procs, VkInstance instance)
HRESULT	vkd3d_load_vk_device_procs (struct vkd3d_vk_device_procs *procs, const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device)
bool	vkd3d_get_program_name (char program_name[PATH_MAX])
VkResult	vkd3d_set_vk_object_name_utf8 (struct d3d12_device *device, uint64_t vk_object, VkDebugReportObjectTypeEXT vk_object_type, const char *name)
HRESULT	vkd3d_set_vk_object_name (struct d3d12_device *device, uint64_t vk_object, VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name)
static void	vk_prepend_struct (void *header, void *structure)
static void	vkd3d_prepend_struct (void *header, void *structure)
int	vkd3d_shader_open_cache (struct vkd3d_shader_cache **cache)
unsigned int	vkd3d_shader_cache_incref (struct vkd3d_shader_cache *cache)
unsigned int	vkd3d_shader_cache_decref (struct vkd3d_shader_cache *cache)
int	vkd3d_shader_cache_put (struct vkd3d_shader_cache *cache, const void *key, size_t key_size, const void *value, size_t value_size)
int	vkd3d_shader_cache_get (struct vkd3d_shader_cache *cache, const void *key, size_t key_size, void *value, size_t *value_size)

Variables
uint64_t	object_global_serial_id
enum vkd3d_vk_descriptor_set_index	vk_descriptor_set_index_table []
const char	vkd3d_build []

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file vkd3d_private.h.

CONST_VTABLE

#define CONST_VTABLE

Definition at line 28 of file vkd3d_private.h.

DECLARE_VK_PFN

#define DECLARE_VK_PFN

(

name

)

PFN_##name name;

Definition at line 81 of file vkd3d_private.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 of file vkd3d_private.h.

VK_CALL

#define VK_CALL

(

f

)

(vk_procs->f)

Definition at line 44 of file vkd3d_private.h.

VK_DEVICE_EXT_PFN

#define VK_DEVICE_EXT_PFN   DECLARE_VK_PFN

Definition at line 93 of file vkd3d_private.h.

VK_DEVICE_PFN

#define VK_DEVICE_PFN   DECLARE_VK_PFN

Definition at line 92 of file vkd3d_private.h.

VK_INSTANCE_EXT_PFN

#define VK_INSTANCE_EXT_PFN   DECLARE_VK_PFN

Definition at line 85 of file vkd3d_private.h.

VK_INSTANCE_PFN [1/2]

#define VK_INSTANCE_PFN   DECLARE_VK_PFN

Definition at line 91 of file vkd3d_private.h.

VK_INSTANCE_PFN [2/2]

#define VK_INSTANCE_PFN   DECLARE_VK_PFN

Definition at line 91 of file vkd3d_private.h.

VK_NO_PROTOTYPES

#define VK_NO_PROTOTYPES

Definition at line 27 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_CBV

#define VKD3D_DESCRIPTOR_MAGIC_CBV   VKD3D_MAKE_TAG('C', 'B', 'V', 0)

Definition at line 47 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_DSV

#define VKD3D_DESCRIPTOR_MAGIC_DSV   VKD3D_MAKE_TAG('D', 'S', 'V', 0)

Definition at line 51 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_FREE

#define VKD3D_DESCRIPTOR_MAGIC_FREE   0x00000000u

Definition at line 46 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_RTV

#define VKD3D_DESCRIPTOR_MAGIC_RTV   VKD3D_MAKE_TAG('R', 'T', 'V', 0)

Definition at line 52 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_SAMPLER

#define VKD3D_DESCRIPTOR_MAGIC_SAMPLER   VKD3D_MAKE_TAG('S', 'M', 'P', 0)

Definition at line 50 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_SRV

#define VKD3D_DESCRIPTOR_MAGIC_SRV   VKD3D_MAKE_TAG('S', 'R', 'V', 0)

Definition at line 48 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_MAGIC_UAV

#define VKD3D_DESCRIPTOR_MAGIC_UAV   VKD3D_MAKE_TAG('U', 'A', 'V', 0)

Definition at line 49 of file vkd3d_private.h.

VKD3D_DESCRIPTOR_POOL_COUNT

#define VKD3D_DESCRIPTOR_POOL_COUNT   6

Definition at line 1531 of file vkd3d_private.h.

VKD3D_MAX_COMPATIBLE_FORMAT_COUNT

#define VKD3D_MAX_COMPATIBLE_FORMAT_COUNT   6u

Definition at line 54 of file vkd3d_private.h.

VKD3D_MAX_DESCRIPTOR_SET_SAMPLERS

#define VKD3D_MAX_DESCRIPTOR_SET_SAMPLERS   2048u

Definition at line 62 of file vkd3d_private.h.

VKD3D_MAX_DESCRIPTOR_SETS

#define VKD3D_MAX_DESCRIPTOR_SETS   64u

Definition at line 60 of file vkd3d_private.h.

VKD3D_MAX_DEVICE_BLOCKED_QUEUES

#define VKD3D_MAX_DEVICE_BLOCKED_QUEUES   16u

Definition at line 59 of file vkd3d_private.h.

VKD3D_MAX_QUEUE_FAMILY_COUNT

#define VKD3D_MAX_QUEUE_FAMILY_COUNT   3u

Definition at line 55 of file vkd3d_private.h.

VKD3D_MAX_SHADER_EXTENSIONS

#define VKD3D_MAX_SHADER_EXTENSIONS   5u

Definition at line 56 of file vkd3d_private.h.

VKD3D_MAX_SHADER_STAGES

#define VKD3D_MAX_SHADER_STAGES   5u

Definition at line 57 of file vkd3d_private.h.

VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE

#define VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE   (16 * 1024u)

Definition at line 66 of file vkd3d_private.h.

VKD3D_MAX_VK_SYNC_OBJECTS

#define VKD3D_MAX_VK_SYNC_OBJECTS   4u

Definition at line 58 of file vkd3d_private.h.

VKD3D_RESOURCE_DEDICATED_HEAP

#define VKD3D_RESOURCE_DEDICATED_HEAP   0x00000008

Definition at line 444 of file vkd3d_private.h.

VKD3D_RESOURCE_EXTERNAL

#define VKD3D_RESOURCE_EXTERNAL   0x00000004

Definition at line 443 of file vkd3d_private.h.

VKD3D_RESOURCE_LINEAR_TILING

#define VKD3D_RESOURCE_LINEAR_TILING   0x00000010

Definition at line 445 of file vkd3d_private.h.

VKD3D_RESOURCE_PUBLIC_FLAGS

#define VKD3D_RESOURCE_PUBLIC_FLAGS    (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION)

Definition at line 441 of file vkd3d_private.h.

WIDL_C_INLINE_WRAPPERS

#define WIDL_C_INLINE_WRAPPERS

Definition at line 23 of file vkd3d_private.h.

Enumeration Type Documentation

vkd3d_config_flags

enum vkd3d_config_flags

Enumerator
VKD3D_CONFIG_FLAG_VULKAN_DEBUG
VKD3D_CONFIG_FLAG_VIRTUAL_HEAPS

Definition at line 172 of file vkd3d_private.h.

{
    VKD3D_CONFIG_FLAG_VULKAN_DEBUG = 0x00000001,
    VKD3D_CONFIG_FLAG_VIRTUAL_HEAPS = 0x00000002,
};

vkd3d_cs_op

enum vkd3d_cs_op

Enumerator
VKD3D_CS_OP_WAIT
VKD3D_CS_OP_SIGNAL
VKD3D_CS_OP_EXECUTE
VKD3D_CS_OP_UPDATE_MAPPINGS
VKD3D_CS_OP_COPY_MAPPINGS

Definition at line 1335 of file vkd3d_private.h.

{
    VKD3D_CS_OP_WAIT,
    VKD3D_CS_OP_SIGNAL,
    VKD3D_CS_OP_EXECUTE,
    VKD3D_CS_OP_UPDATE_MAPPINGS,
    VKD3D_CS_OP_COPY_MAPPINGS,
};

vkd3d_format_type

enum vkd3d_format_type

Enumerator
VKD3D_FORMAT_TYPE_OTHER
VKD3D_FORMAT_TYPE_TYPELESS
VKD3D_FORMAT_TYPE_SINT
VKD3D_FORMAT_TYPE_UINT

Definition at line 1638 of file vkd3d_private.h.

{
    VKD3D_FORMAT_TYPE_OTHER,
    VKD3D_FORMAT_TYPE_TYPELESS,
    VKD3D_FORMAT_TYPE_SINT,
    VKD3D_FORMAT_TYPE_UINT,
};

vkd3d_pipeline_bind_point

enum vkd3d_pipeline_bind_point

Enumerator
VKD3D_PIPELINE_BIND_POINT_GRAPHICS
VKD3D_PIPELINE_BIND_POINT_COMPUTE
VKD3D_PIPELINE_BIND_POINT_COUNT

Definition at line 1244 of file vkd3d_private.h.

{
    VKD3D_PIPELINE_BIND_POINT_GRAPHICS = 0x0,
    VKD3D_PIPELINE_BIND_POINT_COMPUTE = 0x1,
    VKD3D_PIPELINE_BIND_POINT_COUNT = 0x2,
};

vkd3d_view_type

enum vkd3d_view_type

Enumerator
VKD3D_VIEW_TYPE_BUFFER
VKD3D_VIEW_TYPE_IMAGE
VKD3D_VIEW_TYPE_SAMPLER

Definition at line 568 of file vkd3d_private.h.

{
    VKD3D_VIEW_TYPE_BUFFER,
    VKD3D_VIEW_TYPE_IMAGE,
    VKD3D_VIEW_TYPE_SAMPLER,
};

vkd3d_vk_descriptor_set_index

enum vkd3d_vk_descriptor_set_index

Enumerator
VKD3D_SET_INDEX_SAMPLER
VKD3D_SET_INDEX_UAV_COUNTER
VKD3D_SET_INDEX_MUTABLE
VKD3D_SET_INDEX_UNIFORM_BUFFER
VKD3D_SET_INDEX_UNIFORM_TEXEL_BUFFER
VKD3D_SET_INDEX_SAMPLED_IMAGE
VKD3D_SET_INDEX_STORAGE_TEXEL_BUFFER
VKD3D_SET_INDEX_STORAGE_IMAGE
VKD3D_SET_INDEX_COUNT

Definition at line 773 of file vkd3d_private.h.

{
    VKD3D_SET_INDEX_SAMPLER,
    VKD3D_SET_INDEX_UAV_COUNTER,
    VKD3D_SET_INDEX_MUTABLE,
 
    /* These are used when mutable descriptors are not available to back
     * SRV-UAV-CBV descriptor heaps. They must stay at the end of this
     * enumeration, so that they can be ignored when mutable descriptors are
     * used. */
    VKD3D_SET_INDEX_UNIFORM_BUFFER = VKD3D_SET_INDEX_MUTABLE,
    VKD3D_SET_INDEX_UNIFORM_TEXEL_BUFFER,
    VKD3D_SET_INDEX_SAMPLED_IMAGE,
    VKD3D_SET_INDEX_STORAGE_TEXEL_BUFFER,
    VKD3D_SET_INDEX_STORAGE_IMAGE,
 
    VKD3D_SET_INDEX_COUNT
};

Function Documentation

d3d12_box_is_empty()

static bool d3d12_box_is_empty ( const D3D12_BOX *  box )

inlinestatic

Definition at line 1692 of file vkd3d_private.h.

{
    return box->right <= box->left || box->bottom <= box->top || box->back <= box->front;
}

Referenced by d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

d3d12_command_allocator_create()

HRESULT d3d12_command_allocator_create	(	struct d3d12_device *	device,
		D3D12_COMMAND_LIST_TYPE	type,
		struct d3d12_command_allocator **	allocator
	)

Definition at line 1895 of file command.c.

{
    struct d3d12_command_allocator *object;
    HRESULT hr;
 
    if (!(D3D12_COMMAND_LIST_TYPE_DIRECT <= type && type <= D3D12_COMMAND_LIST_TYPE_COPY))
    {
        WARN("Invalid type %#x.\n", type);
        return E_INVALIDARG;
    }
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_command_allocator_init(object, device, type)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created command allocator %p.\n", object);
 
    *allocator = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateCommandAllocator().

d3d12_command_list_create()

HRESULT d3d12_command_list_create	(	struct d3d12_device *	device,
		UINT	node_mask,
		D3D12_COMMAND_LIST_TYPE	type,
		ID3D12CommandAllocator *	allocator_iface,
		ID3D12PipelineState *	initial_pipeline_state,
		struct d3d12_command_list **	list
	)

Definition at line 6262 of file command.c.

{
    struct d3d12_command_allocator *allocator;
    struct d3d12_command_list *object;
    HRESULT hr;
 
    if (!(allocator = unsafe_impl_from_ID3D12CommandAllocator(allocator_iface)))
    {
        WARN("Command allocator is NULL.\n");
        return E_INVALIDARG;
    }
 
    if (allocator->type != type)
    {
        WARN("Command list types do not match (allocator %#x, list %#x).\n",
                allocator->type, type);
        return E_INVALIDARG;
    }
 
    debug_ignored_node_mask(node_mask);
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_command_list_init(object, device, type, allocator, initial_pipeline_state)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created command list %p.\n", object);
 
    *list = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateCommandList().

d3d12_command_queue_create()

HRESULT d3d12_command_queue_create	(	struct d3d12_device *	device,
		const D3D12_COMMAND_QUEUE_DESC *	desc,
		struct d3d12_command_queue **	queue
	)

Definition at line 7464 of file command.c.

{
    struct d3d12_command_queue *object;
    HRESULT hr;
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_command_queue_init(object, device, desc)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created command queue %p.\n", object);
 
    *queue = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateCommandQueue().

d3d12_command_signature_create()

HRESULT d3d12_command_signature_create	(	struct d3d12_device *	device,
		const D3D12_COMMAND_SIGNATURE_DESC *	desc,
		struct d3d12_command_signature **	signature
	)

Definition at line 7635 of file command.c.

{
    struct d3d12_command_signature *object;
    unsigned int i;
    HRESULT hr;
 
    for (i = 0; i < desc->NumArgumentDescs; ++i)
    {
        const D3D12_INDIRECT_ARGUMENT_DESC *argument_desc = &desc->pArgumentDescs[i];
        switch (argument_desc->Type)
        {
            case D3D12_INDIRECT_ARGUMENT_TYPE_DRAW:
            case D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED:
            case D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH:
                if (i != desc->NumArgumentDescs - 1)
                {
                    WARN("Draw/dispatch must be the last element of a command signature.\n");
                    return E_INVALIDARG;
                }
                break;
            default:
                break;
        }
    }
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    object->ID3D12CommandSignature_iface.lpVtbl = &d3d12_command_signature_vtbl;
    object->refcount = 1;
    object->internal_refcount = 1;
 
    object->desc = *desc;
    if (!(object->desc.pArgumentDescs = vkd3d_calloc(desc->NumArgumentDescs, sizeof(*desc->pArgumentDescs))))
    {
        vkd3d_free(object);
        return E_OUTOFMEMORY;
    }
    memcpy((void *)object->desc.pArgumentDescs, desc->pArgumentDescs,
            desc->NumArgumentDescs * sizeof(*desc->pArgumentDescs));
 
    if (FAILED(hr = vkd3d_private_store_init(&object->private_store)))
    {
        vkd3d_free((void *)object->desc.pArgumentDescs);
        vkd3d_free(object);
        return hr;
    }
 
    d3d12_device_add_ref(object->device = device);
 
    TRACE("Created command signature %p.\n", object);
 
    *signature = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateCommandSignature().

d3d12_committed_resource_create()

HRESULT d3d12_committed_resource_create	(	struct d3d12_device *	device,
		const D3D12_HEAP_PROPERTIES *	heap_properties,
		D3D12_HEAP_FLAGS	heap_flags,
		const D3D12_RESOURCE_DESC1 *	desc,
		D3D12_RESOURCE_STATES	initial_state,
		const D3D12_CLEAR_VALUE *	optimized_clear_value,
		ID3D12ProtectedResourceSession *	protected_session,
		struct d3d12_resource **	resource
	)

Definition at line 2112 of file resource.c.

{
    struct d3d12_resource *object;
    HRESULT hr;
 
    if (!heap_properties)
    {
        WARN("Heap properties are NULL.\n");
        return E_INVALIDARG;
    }
 
    if (protected_session)
        FIXME("Protected session is not supported.\n");
 
    if (FAILED(hr = d3d12_resource_create(device, heap_properties, heap_flags,
            desc, initial_state, optimized_clear_value, &object)))
        return hr;
 
    if (FAILED(hr = vkd3d_allocate_resource_memory(device, object, heap_properties, heap_flags)))
    {
        d3d12_resource_Release(&object->ID3D12Resource2_iface);
        return hr;
    }
 
    TRACE("Created committed resource %p.\n", object);
 
    *resource = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateCommittedResource(), d3d12_device_CreateCommittedResource1(), and d3d12_device_CreateCommittedResource2().

d3d12_desc_copy()

void d3d12_desc_copy	(	struct d3d12_desc *	dst,
		const struct d3d12_desc *	src,
		struct d3d12_descriptor_heap *	dst_heap,
		struct d3d12_device *	device
	)

Definition at line 2723 of file resource.c.

{
    struct d3d12_desc tmp;
 
    VKD3D_ASSERT(dst != src);
 
    tmp.s.u.object = d3d12_desc_get_object_ref(src, device);
    descriptor_heap_write_atomic(dst_heap, dst, &tmp, device);
}

Referenced by d3d12_device_CopyDescriptors().

d3d12_desc_copy_raw()

static void d3d12_desc_copy_raw ( struct d3d12_desc *  dst, const struct d3d12_desc *  src  )

inlinestatic

Definition at line 710 of file vkd3d_private.h.

{
    dst->s = src->s;
}

d3d12_desc_create_cbv()

void d3d12_desc_create_cbv	(	struct d3d12_desc *	descriptor,
		struct d3d12_device *	device,
		const D3D12_CONSTANT_BUFFER_VIEW_DESC *	desc
	)

Definition at line 3140 of file resource.c.

{
    struct VkDescriptorBufferInfo *buffer_info;
    struct vkd3d_cbuffer_desc *cb_desc;
    struct d3d12_resource *resource;
 
    if (!desc)
    {
        WARN("Constant buffer desc is NULL.\n");
        return;
    }
 
    if (!(cb_desc = vkd3d_cbuffer_desc_create(device)))
    {
        ERR("Failed to allocate descriptor object.\n");
        return;
    }
 
    if (desc->SizeInBytes & (D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT - 1))
    {
        WARN("Size is not %u bytes aligned.\n", D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
        return;
    }
 
    buffer_info = &cb_desc->vk_cbv_info;
    if (desc->BufferLocation)
    {
        resource = vkd3d_gpu_va_allocator_dereference(&device->gpu_va_allocator, desc->BufferLocation);
        buffer_info->buffer = resource->u.vk_buffer;
        buffer_info->offset = desc->BufferLocation - resource->gpu_address;
        buffer_info->range = min(desc->SizeInBytes, resource->desc.Width - buffer_info->offset);
    }
    else
    {
        /* NULL descriptor */
        buffer_info->buffer = device->null_resources.vk_buffer;
        buffer_info->offset = 0;
        buffer_info->range = VK_WHOLE_SIZE;
    }
 
    descriptor->s.u.cb_desc = cb_desc;
}

Referenced by d3d12_device_CreateConstantBufferView().

d3d12_desc_create_sampler()

void d3d12_desc_create_sampler	(	struct d3d12_desc *	sampler,
		struct d3d12_device *	device,
		const D3D12_SAMPLER_DESC *	desc
	)

Definition at line 3780 of file resource.c.

{
    D3D12_STATIC_BORDER_COLOR static_colour = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
    struct vkd3d_view *view;
 
    if (!desc)
    {
        WARN("NULL sampler desc.\n");
        return;
    }
 
    if (desc->AddressU == D3D12_TEXTURE_ADDRESS_MODE_BORDER
            || desc->AddressV == D3D12_TEXTURE_ADDRESS_MODE_BORDER
            || desc->AddressW == D3D12_TEXTURE_ADDRESS_MODE_BORDER)
        static_colour = d3d12_static_border_colour(desc->BorderColor);
 
    if (!(view = vkd3d_view_create(VKD3D_DESCRIPTOR_MAGIC_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLER,
            VKD3D_VIEW_TYPE_SAMPLER, device)))
        return;
    view->v.u.vk_sampler = VK_NULL_HANDLE;
    view->v.format = NULL;
 
    if (d3d12_create_sampler(device, desc->Filter, desc->AddressU, desc->AddressV,
            desc->AddressW, desc->MipLODBias, desc->MaxAnisotropy, desc->ComparisonFunc,
            static_colour, desc->MinLOD, desc->MaxLOD, &view->v.u.vk_sampler) < 0)
    {
        vkd3d_view_decref(view, device);
        return;
    }
 
    sampler->s.u.view = view;
}

Referenced by d3d12_device_CreateSampler().

d3d12_desc_create_srv()

void d3d12_desc_create_srv	(	struct d3d12_desc *	descriptor,
		struct d3d12_device *	device,
		struct d3d12_resource *	resource,
		const D3D12_SHADER_RESOURCE_VIEW_DESC *	desc
	)

Definition at line 3302 of file resource.c.

{
    struct vkd3d_texture_view_desc vkd3d_desc;
 
    if (!resource)
    {
        vkd3d_create_null_srv(descriptor, device, desc);
        return;
    }
 
    if (d3d12_resource_is_buffer(resource))
    {
        vkd3d_create_buffer_srv(descriptor, device, resource, desc);
        return;
    }
 
    if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0))
        return;
 
    vkd3d_desc.miplevel_count = VK_REMAINING_MIP_LEVELS;
    vkd3d_desc.allowed_swizzle = true;
    vkd3d_desc.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
 
    if (desc)
    {
        if (desc->Shader4ComponentMapping != D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING)
        {
            TRACE("Component mapping %s for format %#x.\n",
                    debug_d3d12_shader_component_mapping(desc->Shader4ComponentMapping), desc->Format);
 
            vk_component_mapping_from_d3d12(&vkd3d_desc.components, desc->Shader4ComponentMapping);
        }
 
        switch (desc->ViewDimension)
        {
            case D3D12_SRV_DIMENSION_TEXTURE1D:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_1D;
                vkd3d_desc.miplevel_idx = desc->u.Texture1D.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.Texture1D.MipLevels;
                break;
            case D3D12_SRV_DIMENSION_TEXTURE2D:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D;
                vkd3d_desc.miplevel_idx = desc->u.Texture2D.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.Texture2D.MipLevels;
                if (desc->u.Texture2D.PlaneSlice)
                    vkd3d_desc.vk_image_aspect = vk_image_aspect_flags_from_d3d12_plane_slice(resource->format,
                            desc->u.Texture2D.PlaneSlice);
                if (desc->u.Texture2D.ResourceMinLODClamp)
                    FIXME("Unhandled min LOD clamp %.8e.\n", desc->u.Texture2D.ResourceMinLODClamp);
                break;
            case D3D12_SRV_DIMENSION_TEXTURE2DARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.miplevel_idx = desc->u.Texture2DArray.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.Texture2DArray.MipLevels;
                vkd3d_desc.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DArray.ArraySize;
                if (desc->u.Texture2DArray.PlaneSlice)
                    vkd3d_desc.vk_image_aspect = vk_image_aspect_flags_from_d3d12_plane_slice(resource->format,
                            desc->u.Texture2DArray.PlaneSlice);
                if (desc->u.Texture2DArray.ResourceMinLODClamp)
                    FIXME("Unhandled min LOD clamp %.8e.\n", desc->u.Texture2DArray.ResourceMinLODClamp);
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            case D3D12_SRV_DIMENSION_TEXTURE2DMS:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D;
                break;
            case D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DMSArray.ArraySize;
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            case D3D12_SRV_DIMENSION_TEXTURE3D:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_3D;
                vkd3d_desc.miplevel_idx = desc->u.Texture3D.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.Texture3D.MipLevels;
                if (desc->u.Texture3D.ResourceMinLODClamp)
                    FIXME("Unhandled min LOD clamp %.8e.\n", desc->u.Texture2D.ResourceMinLODClamp);
                break;
            case D3D12_SRV_DIMENSION_TEXTURECUBE:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_CUBE;
                vkd3d_desc.miplevel_idx = desc->u.TextureCube.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.TextureCube.MipLevels;
                vkd3d_desc.layer_count = 6;
                if (desc->u.TextureCube.ResourceMinLODClamp)
                    FIXME("Unhandled min LOD clamp %.8e.\n", desc->u.TextureCube.ResourceMinLODClamp);
                break;
            case D3D12_SRV_DIMENSION_TEXTURECUBEARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
                vkd3d_desc.miplevel_idx = desc->u.TextureCubeArray.MostDetailedMip;
                vkd3d_desc.miplevel_count = desc->u.TextureCubeArray.MipLevels;
                vkd3d_desc.layer_idx = desc->u.TextureCubeArray.First2DArrayFace;
                vkd3d_desc.layer_count = desc->u.TextureCubeArray.NumCubes;
                if (vkd3d_desc.layer_count != UINT_MAX)
                    vkd3d_desc.layer_count *= 6;
                if (desc->u.TextureCubeArray.ResourceMinLODClamp)
                    FIXME("Unhandled min LOD clamp %.8e.\n", desc->u.TextureCubeArray.ResourceMinLODClamp);
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            default:
                FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
        }
    }
 
    vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_SRV, resource->u.vk_image, &vkd3d_desc,
            &descriptor->s.u.view);
}

Referenced by d3d12_device_CreateShaderResourceView().

d3d12_desc_create_uav()

void d3d12_desc_create_uav	(	struct d3d12_desc *	descriptor,
		struct d3d12_device *	device,
		struct d3d12_resource *	resource,
		struct d3d12_resource *	counter_resource,
		const D3D12_UNORDERED_ACCESS_VIEW_DESC *	desc
	)

Definition at line 3589 of file resource.c.

{
    if (!resource)
    {
        if (counter_resource)
            FIXME("Ignoring counter resource %p.\n", counter_resource);
        vkd3d_create_null_uav(descriptor, device, desc);
        return;
    }
 
    if (d3d12_resource_is_buffer(resource))
    {
        vkd3d_create_buffer_uav(descriptor, device, resource, counter_resource, desc);
    }
    else
    {
        if (counter_resource)
            FIXME("Unexpected counter resource for texture view.\n");
        vkd3d_create_texture_uav(descriptor, device, resource, desc);
    }
}

Referenced by d3d12_device_CreateUnorderedAccessView().

d3d12_desc_flush_vk_heap_updates_locked()

void d3d12_desc_flush_vk_heap_updates_locked	(	struct d3d12_descriptor_heap *	descriptor_heap,
		struct d3d12_device *	device
	)

Definition at line 2639 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    struct d3d12_desc *descriptors, *src;
    struct descriptor_writes writes;
    union d3d12_desc_object u;
    unsigned int i, next;
 
    if ((i = vkd3d_atomic_exchange_u32(&descriptor_heap->dirty_list_head, UINT_MAX)) == UINT_MAX)
        return;
 
    writes.null_vk_cbv_info.buffer = VK_NULL_HANDLE;
    writes.null_vk_cbv_info.offset = 0;
    writes.null_vk_cbv_info.range = VK_WHOLE_SIZE;
    writes.null_vk_buffer_view = VK_NULL_HANDLE;
    writes.count = 0;
    writes.held_ref_count = 0;
 
    descriptors = (struct d3d12_desc *)descriptor_heap->descriptors;
 
    for (; i != UINT_MAX; i = next)
    {
        src = &descriptors[i];
        next = vkd3d_atomic_exchange_u32(&src->next, 0);
        next = (int)next >> 1;
 
        /* A race exists here between updating src->next and getting the current object. The best
         * we can do is get the object last, which may result in a harmless rewrite later. */
        u.object = d3d12_desc_get_object_ref(src, device);
 
        if (!u.object)
            continue;
 
        writes.held_refs[writes.held_ref_count++] = u.object;
        d3d12_desc_write_vk_heap(descriptor_heap, i, &writes, u.object, device);
    }
 
    /* Avoid thunk calls wherever possible. */
    if (writes.count)
        VK_CALL(vkUpdateDescriptorSets(device->vk_device, writes.count, writes.vk_descriptor_writes, 0, NULL));
    descriptor_writes_free_object_refs(&writes, device);
}

Referenced by command_list_add_descriptor_heap(), command_list_flush_vk_heap_updates(), and device_worker_main().

d3d12_desc_from_cpu_handle()

static struct d3d12_desc * d3d12_desc_from_cpu_handle ( D3D12_CPU_DESCRIPTOR_HANDLE  cpu_handle )

inlinestatic

Definition at line 700 of file vkd3d_private.h.

{
    return (struct d3d12_desc *)cpu_handle.ptr;
}

Referenced by d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_device_CopyDescriptors(), d3d12_device_CreateConstantBufferView(), d3d12_device_CreateSampler(), d3d12_device_CreateShaderResourceView(), and d3d12_device_CreateUnorderedAccessView().

d3d12_desc_from_gpu_handle()

static struct d3d12_desc * d3d12_desc_from_gpu_handle ( D3D12_GPU_DESCRIPTOR_HANDLE  gpu_handle )

inlinestatic

Definition at line 705 of file vkd3d_private.h.

{
    return (struct d3d12_desc *)(intptr_t)gpu_handle.ptr;
}

Referenced by d3d12_command_list_set_descriptor_table().

d3d12_desc_get_descriptor_heap()

static struct d3d12_descriptor_heap * d3d12_desc_get_descriptor_heap ( const struct d3d12_desc *  descriptor )

inlinestatic

Definition at line 855 of file vkd3d_private.h.

{
    return CONTAINING_RECORD(descriptor - descriptor->index, struct d3d12_descriptor_heap, descriptors);
}

Referenced by d3d12_command_list_bind_descriptor_table(), d3d12_command_list_set_descriptor_table(), d3d12_desc_heap_range_size(), d3d12_desc_write_atomic(), and d3d12_device_CopyDescriptors().

d3d12_desc_get_object_ref()

static void * d3d12_desc_get_object_ref ( const volatile struct d3d12_desc *  src, struct d3d12_device *  device  )

inlinestatic

Definition at line 677 of file vkd3d_private.h.

{
    void *view;
 
    /* Some games, e.g. Shadow of the Tomb Raider, GRID 2019, and Horizon Zero Dawn, write descriptors
     * from multiple threads without synchronisation. This is apparently valid in Windows. */
    for (;;)
    {
        do
        {
            if (!(view = src->s.u.object))
                return NULL;
        } while (!vkd3d_view_incref(view));
 
        /* Check if the object is still in src to handle the case where it was
         * already freed and reused elsewhere when the refcount was incremented. */
        if (view == src->s.u.object)
            return view;
 
        vkd3d_view_decref(view, device);
    }
}

Referenced by d3d12_desc_copy(), and d3d12_desc_flush_vk_heap_updates_locked().

d3d12_desc_heap_range_size()

static unsigned int d3d12_desc_heap_range_size ( const struct d3d12_desc *  descriptor )

inlinestatic

Definition at line 860 of file vkd3d_private.h.

{
    const struct d3d12_descriptor_heap *heap = d3d12_desc_get_descriptor_heap(descriptor);
    return heap->desc.NumDescriptors - descriptor->index;
}

Referenced by d3d12_command_list_prepare_descriptors(), and d3d12_command_list_update_descriptor_table().

d3d12_desc_write_atomic()

void d3d12_desc_write_atomic	(	struct d3d12_desc *	dst,
		const struct d3d12_desc *	src,
		struct d3d12_device *	device
	)

Definition at line 2710 of file resource.c.

{
    descriptor_heap_write_atomic(d3d12_desc_get_descriptor_heap(dst), dst, src, device);
}

Referenced by d3d12_device_CreateConstantBufferView(), d3d12_device_CreateSampler(), d3d12_device_CreateShaderResourceView(), and d3d12_device_CreateUnorderedAccessView().

d3d12_descriptor_heap_create()

HRESULT d3d12_descriptor_heap_create	(	struct d3d12_device *	device,
		const D3D12_DESCRIPTOR_HEAP_DESC *	desc,
		struct d3d12_descriptor_heap **	descriptor_heap
	)

Definition at line 4366 of file resource.c.

{
    size_t max_descriptor_count, descriptor_size;
    struct d3d12_descriptor_heap *object;
    struct d3d12_desc *dst;
    unsigned int i;
    HRESULT hr;
 
    if (!(descriptor_size = d3d12_device_get_descriptor_handle_increment_size(device, desc->Type)))
    {
        WARN("No descriptor size for descriptor type %#x.\n", desc->Type);
        return E_INVALIDARG;
    }
 
    if ((desc->Flags & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)
            && (desc->Type == D3D12_DESCRIPTOR_HEAP_TYPE_RTV || desc->Type == D3D12_DESCRIPTOR_HEAP_TYPE_DSV))
    {
        WARN("RTV/DSV descriptor heaps cannot be shader visible.\n");
        return E_INVALIDARG;
    }
 
    max_descriptor_count = (~(size_t)0 - sizeof(*object)) / descriptor_size;
    if (desc->NumDescriptors > max_descriptor_count)
    {
        WARN("Invalid descriptor count %u (max %zu).\n", desc->NumDescriptors, max_descriptor_count);
        return E_OUTOFMEMORY;
    }
 
    if (!(object = vkd3d_malloc(offsetof(struct d3d12_descriptor_heap,
            descriptors[descriptor_size * desc->NumDescriptors]))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_descriptor_heap_init(object, device, desc)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    if (desc->Type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV || desc->Type == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER)
    {
        dst = (struct d3d12_desc *)object->descriptors;
        for (i = 0; i < desc->NumDescriptors; ++i)
        {
            memset(&dst[i].s, 0, sizeof(dst[i].s));
            dst[i].index = i;
            dst[i].next = 0;
        }
        object->dirty_list_head = UINT_MAX;
 
        if (object->use_vk_heaps && FAILED(hr = d3d12_device_add_descriptor_heap(device, object)))
        {
            vkd3d_free(object);
            return hr;
        }
    }
    else
    {
        memset(object->descriptors, 0, descriptor_size * desc->NumDescriptors);
    }
 
    TRACE("Created descriptor heap %p.\n", object);
 
    *descriptor_heap = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateDescriptorHeap().

d3d12_device_add_descriptor_heap()

HRESULT d3d12_device_add_descriptor_heap	(	struct d3d12_device *	device,
		struct d3d12_descriptor_heap *	heap
	)

Definition at line 5569 of file device.c.

{
    vkd3d_mutex_lock(&device->worker_mutex);
 
    if (!vkd3d_array_reserve((void **)&device->heaps, &device->heap_capacity, device->heap_count + 1,
            sizeof(*device->heaps)))
    {
        vkd3d_mutex_unlock(&device->worker_mutex);
        return E_OUTOFMEMORY;
    }
    device->heaps[device->heap_count++] = heap;
 
    vkd3d_mutex_unlock(&device->worker_mutex);
 
    return S_OK;
}

Referenced by d3d12_descriptor_heap_create().

d3d12_device_add_ref()

static ULONG d3d12_device_add_ref ( struct d3d12_device *  device )

inlinestatic

Definition at line 1621 of file vkd3d_private.h.

{
    return ID3D12Device9_AddRef(&device->ID3D12Device9_iface);
}

Referenced by d3d12_cache_session_init(), d3d12_command_allocator_init(), d3d12_command_list_init(), d3d12_command_queue_init(), d3d12_command_signature_create(), d3d12_descriptor_heap_init(), d3d12_fence_init(), d3d12_heap_init(), d3d12_pipeline_state_init_compute(), d3d12_pipeline_state_init_graphics(), d3d12_query_heap_create(), d3d12_resource_AddRef(), d3d12_resource_init(), d3d12_root_signature_init(), and vkd3d_create_image_resource().

d3d12_device_create()

HRESULT d3d12_device_create	(	struct vkd3d_instance *	instance,
		const struct vkd3d_device_create_info *	create_info,
		struct d3d12_device **	device
	)

Definition at line 5534 of file device.c.

{
    struct d3d12_device *object;
    HRESULT hr;
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_device_init(object, instance, create_info)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created device %p.\n", object);
 
    *device = object;
 
    return S_OK;
}

Referenced by vkd3d_create_device().

d3d12_device_get_descriptor_handle_increment_size()

static unsigned int d3d12_device_get_descriptor_handle_increment_size ( struct d3d12_device *  device, D3D12_DESCRIPTOR_HEAP_TYPE  descriptor_type  )

inlinestatic

Definition at line 1631 of file vkd3d_private.h.

{
    return ID3D12Device9_GetDescriptorHandleIncrementSize(&device->ID3D12Device9_iface, descriptor_type);
}

Referenced by d3d12_descriptor_heap_create().

d3d12_device_get_vkd3d_queue()

struct vkd3d_queue * d3d12_device_get_vkd3d_queue	(	struct d3d12_device *	device,
		D3D12_COMMAND_LIST_TYPE	type
	)

Definition at line 1800 of file command.c.

{
    switch (type)
    {
        case D3D12_COMMAND_LIST_TYPE_DIRECT:
            return device->direct_queue;
        case D3D12_COMMAND_LIST_TYPE_COMPUTE:
            return device->compute_queue;
        case D3D12_COMMAND_LIST_TYPE_COPY:
            return device->copy_queue;
        default:
            FIXME("Unhandled command list type %#x.\n", type);
            return NULL;
    }
}

Referenced by d3d12_command_allocator_init(), d3d12_command_queue_init(), and vkd3d_init_null_resources_data().

d3d12_device_is_uma()

bool d3d12_device_is_uma	(	struct d3d12_device *	device,
		bool *	coherent
	)

Definition at line 3358 of file device.c.

{
    unsigned int i;
 
    if (coherent)
        *coherent = true;
 
    for (i = 0; i < device->memory_properties.memoryTypeCount; ++i)
    {
        if (!(device->memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
            return false;
        if (coherent && !(device->memory_properties.memoryTypes[i].propertyFlags
                & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
            *coherent = false;
    }
 
    return true;
}

Referenced by d3d12_device_CheckFeatureSupport(), d3d12_device_GetCustomHeapProperties(), and vkd3d_select_memory_type().

d3d12_device_mark_as_removed()

void d3d12_device_mark_as_removed	(	struct d3d12_device *	device,
		HRESULT	reason,
		const char *	message,
			...
	)

d3d12_device_query_interface()

static HRESULT d3d12_device_query_interface ( struct d3d12_device *  device, REFIID  iid, void **  object  )

inlinestatic

Definition at line 1616 of file vkd3d_private.h.

{
    return ID3D12Device9_QueryInterface(&device->ID3D12Device9_iface, iid, object);
}

Referenced by d3d12_cache_session_GetDevice(), d3d12_command_allocator_GetDevice(), d3d12_command_list_GetDevice(), d3d12_command_queue_GetDevice(), d3d12_command_signature_GetDevice(), d3d12_descriptor_heap_GetDevice(), d3d12_fence_GetDevice(), d3d12_heap_GetDevice(), d3d12_pipeline_state_GetDevice(), d3d12_query_heap_GetDevice(), d3d12_resource_GetDevice(), and d3d12_root_signature_GetDevice().

d3d12_device_release()

static ULONG d3d12_device_release ( struct d3d12_device *  device )

inlinestatic

Definition at line 1626 of file vkd3d_private.h.

{
    return ID3D12Device9_Release(&device->ID3D12Device9_iface);
}

Referenced by d3d12_cache_session_destroy(), d3d12_command_allocator_Release(), d3d12_command_list_init(), d3d12_command_list_Release(), d3d12_command_queue_Release(), d3d12_command_signature_decref(), d3d12_descriptor_heap_Release(), d3d12_fence_decref(), d3d12_heap_destroy(), d3d12_pipeline_state_Release(), d3d12_query_heap_Release(), d3d12_resource_Release(), and d3d12_root_signature_Release().

d3d12_device_remove_descriptor_heap()

void d3d12_device_remove_descriptor_heap	(	struct d3d12_device *	device,
		struct d3d12_descriptor_heap *	heap
	)

Definition at line 5586 of file device.c.

{
    size_t i;
 
    vkd3d_mutex_lock(&device->worker_mutex);
 
    for (i = 0; i < device->heap_count; ++i)
    {
        if (device->heaps[i] == heap)
        {
            device->heaps[i] = device->heaps[--device->heap_count];
            break;
        }
    }
 
    vkd3d_mutex_unlock(&device->worker_mutex);
}

Referenced by d3d12_descriptor_heap_Release().

d3d12_dsv_desc_create_dsv()

void d3d12_dsv_desc_create_dsv	(	struct d3d12_dsv_desc *	dsv_desc,
		struct d3d12_device *	device,
		struct d3d12_resource *	resource,
		const D3D12_DEPTH_STENCIL_VIEW_DESC *	desc
	)

Definition at line 3931 of file resource.c.

{
    struct vkd3d_texture_view_desc vkd3d_desc;
    struct vkd3d_view *view;
 
    d3d12_dsv_desc_destroy(dsv_desc, device);
 
    if (!resource)
    {
        FIXME("NULL resource DSV not implemented.\n");
        return;
    }
 
    if (resource->desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
    {
        WARN("Cannot create DSV for 3D texture.\n");
        return;
    }
 
    if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0))
        return;
 
    vkd3d_desc.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
    if (!(vkd3d_desc.format->vk_aspect_mask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)))
    {
        WARN("Trying to create DSV for format %#x.\n", vkd3d_desc.format->dxgi_format);
        return;
    }
 
    if (desc)
    {
        if (desc->Flags)
            FIXME("Ignoring flags %#x.\n", desc->Flags);
 
        switch (desc->ViewDimension)
        {
            case D3D12_DSV_DIMENSION_TEXTURE2D:
                vkd3d_desc.miplevel_idx = desc->u.Texture2D.MipSlice;
                break;
            case D3D12_DSV_DIMENSION_TEXTURE2DARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.miplevel_idx = desc->u.Texture2DArray.MipSlice;
                vkd3d_desc.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DArray.ArraySize;
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            case D3D12_DSV_DIMENSION_TEXTURE2DMS:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D;
                break;
            case D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DMSArray.ArraySize;
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            default:
                FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
        }
    }
 
    VKD3D_ASSERT(d3d12_resource_is_texture(resource));
 
    if (!vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_DSV, resource->u.vk_image, &vkd3d_desc, &view))
        return;
 
    dsv_desc->sample_count = vk_samples_from_dxgi_sample_desc(&resource->desc.SampleDesc);
    dsv_desc->format = vkd3d_desc.format;
    dsv_desc->width = d3d12_resource_desc_get_width(&resource->desc, vkd3d_desc.miplevel_idx);
    dsv_desc->height = d3d12_resource_desc_get_height(&resource->desc, vkd3d_desc.miplevel_idx);
    dsv_desc->layer_count = vkd3d_desc.layer_count;
    dsv_desc->view = view;
    dsv_desc->resource = resource;
}

Referenced by d3d12_device_CreateDepthStencilView().

d3d12_dsv_desc_from_cpu_handle()

static struct d3d12_dsv_desc * d3d12_dsv_desc_from_cpu_handle ( D3D12_CPU_DESCRIPTOR_HANDLE  cpu_handle )

inlinestatic

Definition at line 765 of file vkd3d_private.h.

{
    return (struct d3d12_dsv_desc *)cpu_handle.ptr;
}

Referenced by d3d12_command_list_ClearDepthStencilView(), d3d12_command_list_OMSetRenderTargets(), and d3d12_device_CreateDepthStencilView().

d3d12_fence_create()

HRESULT d3d12_fence_create	(	struct d3d12_device *	device,
		uint64_t	initial_value,
		D3D12_FENCE_FLAGS	flags,
		struct d3d12_fence **	fence
	)

Definition at line 1222 of file command.c.

{
    struct d3d12_fence *object;
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    d3d12_fence_init(object, device, initial_value, flags);
 
    TRACE("Created fence %p.\n", object);
 
    *fence = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateFence().

d3d12_heap_create()

HRESULT d3d12_heap_create	(	struct d3d12_device *	device,
		const D3D12_HEAP_DESC *	desc,
		const struct d3d12_resource *	resource,
		ID3D12ProtectedResourceSession *	protected_session,
		struct d3d12_heap **	heap
	)

Definition at line 576 of file resource.c.

{
    struct d3d12_heap *object;
    HRESULT hr;
 
    if (protected_session)
        FIXME("Protected session is not supported.\n");
 
    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;
}

Referenced by d3d12_device_CreateHeap(), d3d12_device_CreateHeap1(), and vkd3d_allocate_resource_memory().

d3d12_pipeline_state_create()

HRESULT d3d12_pipeline_state_create	(	struct d3d12_device *	device,
		const D3D12_PIPELINE_STATE_STREAM_DESC *	desc,
		struct d3d12_pipeline_state **	state
	)

Definition at line 3655 of file state.c.

{
    struct d3d12_pipeline_state_desc pipeline_desc;
    struct d3d12_pipeline_state *object;
    VkPipelineBindPoint bind_point;
    HRESULT hr;
 
    if (FAILED(hr = pipeline_state_desc_from_d3d12_stream_desc(&pipeline_desc, desc, &bind_point)))
        return hr;
 
    if (!(object = vkd3d_calloc(1, sizeof(*object))))
        return E_OUTOFMEMORY;
 
    switch (bind_point)
    {
        case VK_PIPELINE_BIND_POINT_COMPUTE:
            hr = d3d12_pipeline_state_init_compute(object, device, &pipeline_desc);
            break;
 
        case VK_PIPELINE_BIND_POINT_GRAPHICS:
            hr = d3d12_pipeline_state_init_graphics(object, device, &pipeline_desc);
            break;
 
        default:
            vkd3d_unreachable();
    }
 
    if (FAILED(hr))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created pipeline state %p.\n", object);
 
    *state = object;
    return S_OK;
}

Referenced by d3d12_device_CreatePipelineState().

d3d12_pipeline_state_create_compute()

HRESULT d3d12_pipeline_state_create_compute	(	struct d3d12_device *	device,
		const D3D12_COMPUTE_PIPELINE_STATE_DESC *	desc,
		struct d3d12_pipeline_state **	state
	)

Definition at line 2621 of file state.c.

{
    struct d3d12_pipeline_state_desc pipeline_desc;
    struct d3d12_pipeline_state *object;
    HRESULT hr;
 
    pipeline_state_desc_from_d3d12_compute_desc(&pipeline_desc, desc);
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_pipeline_state_init_compute(object, device, &pipeline_desc)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created compute pipeline state %p.\n", object);
 
    *state = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateComputePipelineState().

d3d12_pipeline_state_create_graphics()

HRESULT d3d12_pipeline_state_create_graphics	(	struct d3d12_device *	device,
		const D3D12_GRAPHICS_PIPELINE_STATE_DESC *	desc,
		struct d3d12_pipeline_state **	state
	)

Definition at line 3630 of file state.c.

{
    struct d3d12_pipeline_state_desc pipeline_desc;
    struct d3d12_pipeline_state *object;
    HRESULT hr;
 
    pipeline_state_desc_from_d3d12_graphics_desc(&pipeline_desc, desc);
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    if (FAILED(hr = d3d12_pipeline_state_init_graphics(object, device, &pipeline_desc)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created graphics pipeline state %p.\n", object);
 
    *state = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateGraphicsPipelineState().

d3d12_pipeline_state_get_or_create_pipeline()

VkPipeline d3d12_pipeline_state_get_or_create_pipeline	(	struct d3d12_pipeline_state *	state,
		D3D12_PRIMITIVE_TOPOLOGY	topology,
		const uint32_t *	strides,
		VkFormat	dsv_format,
		VkRenderPass *	vk_render_pass
	)

Definition at line 3827 of file state.c.

{
    VkVertexInputBindingDescription bindings[D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT];
    const struct vkd3d_vk_device_procs *vk_procs = &state->device->vk_procs;
    struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics;
    VkPipelineVertexInputDivisorStateCreateInfoEXT input_divisor_info;
    VkPipelineTessellationStateCreateInfo tessellation_info;
    VkPipelineVertexInputStateCreateInfo input_desc;
    VkPipelineInputAssemblyStateCreateInfo ia_desc;
    VkPipelineColorBlendStateCreateInfo blend_desc;
    struct d3d12_device *device = state->device;
    VkGraphicsPipelineCreateInfo pipeline_desc;
    struct vkd3d_pipeline_key pipeline_key;
    size_t binding_count = 0;
    VkPipeline vk_pipeline;
    unsigned int i;
    uint32_t mask;
    VkResult vr;
    HRESULT hr;
 
    static const VkPipelineViewportStateCreateInfo vp_desc =
    {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .viewportCount = 1,
        .pViewports = NULL,
        .scissorCount = 1,
        .pScissors = NULL,
    };
    static const VkDynamicState dynamic_states[] =
    {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR,
        VK_DYNAMIC_STATE_BLEND_CONSTANTS,
        VK_DYNAMIC_STATE_STENCIL_REFERENCE,
        VK_DYNAMIC_STATE_DEPTH_BOUNDS,
    };
    static const VkPipelineDynamicStateCreateInfo dynamic_desc =
    {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
        .pNext = NULL,
        .flags = 0,
        .dynamicStateCount = ARRAY_SIZE(dynamic_states),
        .pDynamicStates = dynamic_states,
    };
 
    VKD3D_ASSERT(d3d12_pipeline_state_is_graphics(state));
 
    memset(&pipeline_key, 0, sizeof(pipeline_key));
    pipeline_key.topology = topology;
 
    for (i = 0, mask = 0; i < graphics->attribute_count; ++i)
    {
        struct VkVertexInputBindingDescription *b;
        uint32_t binding;
 
        binding = graphics->attributes[i].binding;
        if (mask & (1u << binding))
            continue;
 
        if (binding_count == ARRAY_SIZE(bindings))
        {
            FIXME("Maximum binding count exceeded.\n");
            break;
        }
 
        mask |= 1u << binding;
        b = &bindings[binding_count];
        b->binding = binding;
        b->stride = strides[binding];
        b->inputRate = graphics->input_rates[binding];
 
        pipeline_key.strides[binding_count] = strides[binding];
 
        ++binding_count;
    }
 
    pipeline_key.dsv_format = dsv_format;
 
    if ((vk_pipeline = d3d12_pipeline_state_find_compiled_pipeline(state, &pipeline_key, vk_render_pass)))
        return vk_pipeline;
 
    input_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    input_desc.pNext = NULL;
    input_desc.flags = 0;
    input_desc.vertexBindingDescriptionCount = binding_count;
    input_desc.pVertexBindingDescriptions = bindings;
    input_desc.vertexAttributeDescriptionCount = graphics->attribute_count;
    input_desc.pVertexAttributeDescriptions = graphics->attributes;
 
    if (graphics->instance_divisor_count)
    {
        input_desc.pNext = &input_divisor_info;
        input_divisor_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
        input_divisor_info.pNext = NULL;
        input_divisor_info.vertexBindingDivisorCount = graphics->instance_divisor_count;
        input_divisor_info.pVertexBindingDivisors = graphics->instance_divisors;
    }
 
    ia_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    ia_desc.pNext = NULL;
    ia_desc.flags = 0;
    ia_desc.topology = vk_topology_from_d3d12_topology(topology);
    ia_desc.primitiveRestartEnable = graphics->index_buffer_strip_cut_value
            && vk_topology_can_restart(ia_desc.topology);
 
    if (ia_desc.topology == VK_PRIMITIVE_TOPOLOGY_MAX_ENUM)
    {
        WARN("Primitive topology is undefined.\n");
        return VK_NULL_HANDLE;
    }
 
    tessellation_info.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
    tessellation_info.pNext = NULL;
    tessellation_info.flags = 0;
    tessellation_info.patchControlPoints
            = max(topology - D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + 1, 1);
 
    blend_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    blend_desc.pNext = NULL;
    blend_desc.flags = 0;
    blend_desc.logicOpEnable = graphics->om_logic_op_enable;
    blend_desc.logicOp = graphics->om_logic_op;
    blend_desc.attachmentCount = graphics->rt_count;
    blend_desc.pAttachments = graphics->blend_attachments;
    blend_desc.blendConstants[0] = D3D12_DEFAULT_BLEND_FACTOR_RED;
    blend_desc.blendConstants[1] = D3D12_DEFAULT_BLEND_FACTOR_GREEN;
    blend_desc.blendConstants[2] = D3D12_DEFAULT_BLEND_FACTOR_BLUE;
    blend_desc.blendConstants[3] = D3D12_DEFAULT_BLEND_FACTOR_ALPHA;
 
    pipeline_desc.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipeline_desc.pNext = NULL;
    pipeline_desc.flags = 0;
    pipeline_desc.stageCount = graphics->stage_count;
    pipeline_desc.pStages = graphics->stages;
    pipeline_desc.pVertexInputState = &input_desc;
    pipeline_desc.pInputAssemblyState = &ia_desc;
    pipeline_desc.pTessellationState = &tessellation_info;
    pipeline_desc.pViewportState = &vp_desc;
    pipeline_desc.pRasterizationState = &graphics->rs_desc;
    pipeline_desc.pMultisampleState = &graphics->ms_desc;
    pipeline_desc.pDepthStencilState = &graphics->ds_desc;
    pipeline_desc.pColorBlendState = &blend_desc;
    pipeline_desc.pDynamicState = &dynamic_desc;
    pipeline_desc.layout = state->uav_counters.vk_pipeline_layout ? state->uav_counters.vk_pipeline_layout
            : graphics->root_signature->vk_pipeline_layout;
    pipeline_desc.subpass = 0;
    pipeline_desc.basePipelineHandle = VK_NULL_HANDLE;
    pipeline_desc.basePipelineIndex = -1;
 
    /* Create a render pass for pipelines with DXGI_FORMAT_UNKNOWN. */
    if (!(pipeline_desc.renderPass = graphics->render_pass))
    {
        if (graphics->null_attachment_mask & dsv_attachment_mask(graphics))
            TRACE("Compiling %p with DSV format %#x.\n", state, dsv_format);
 
        if (FAILED(hr = d3d12_graphics_pipeline_state_create_render_pass(graphics, device, dsv_format,
                &pipeline_desc.renderPass)))
            return VK_NULL_HANDLE;
    }
 
    *vk_render_pass = pipeline_desc.renderPass;
 
    if ((vr = VK_CALL(vkCreateGraphicsPipelines(device->vk_device, device->vk_pipeline_cache,
            1, &pipeline_desc, NULL, &vk_pipeline))) < 0)
    {
        WARN("Failed to create Vulkan graphics pipeline, vr %d.\n", vr);
        return VK_NULL_HANDLE;
    }
 
    if (d3d12_pipeline_state_put_pipeline_to_cache(state, &pipeline_key, vk_pipeline, pipeline_desc.renderPass))
        return vk_pipeline;
 
    /* Other thread compiled the pipeline before us. */
    VK_CALL(vkDestroyPipeline(device->vk_device, vk_pipeline, NULL));
    vk_pipeline = d3d12_pipeline_state_find_compiled_pipeline(state, &pipeline_key, vk_render_pass);
    if (!vk_pipeline)
        ERR("Could not get the pipeline compiled by other thread from the cache.\n");
    return vk_pipeline;
}

Referenced by d3d12_command_list_update_graphics_pipeline().

d3d12_pipeline_state_has_unknown_dsv_format()

static bool d3d12_pipeline_state_has_unknown_dsv_format ( struct d3d12_pipeline_state *  state )

inlinestatic

Definition at line 1096 of file vkd3d_private.h.

{
    if (d3d12_pipeline_state_is_graphics(state))
    {
        struct d3d12_graphics_pipeline_state *graphics = &state->u.graphics;
 
        return graphics->null_attachment_mask & dsv_attachment_mask(graphics);
    }
 
    return false;
}

Referenced by d3d12_command_list_has_depth_stencil_view(), and d3d12_command_list_OMSetRenderTargets().

d3d12_pipeline_state_is_compute()

static bool d3d12_pipeline_state_is_compute ( const struct d3d12_pipeline_state *  state )

inlinestatic

Definition at line 1086 of file vkd3d_private.h.

{
    return state && state->vk_bind_point == VK_PIPELINE_BIND_POINT_COMPUTE;
}

Referenced by d3d12_command_list_update_compute_pipeline(), d3d12_pipeline_state_Release(), and d3d12_pipeline_state_SetName().

d3d12_pipeline_state_is_graphics()

static bool d3d12_pipeline_state_is_graphics ( const struct d3d12_pipeline_state *  state )

inlinestatic

Definition at line 1091 of file vkd3d_private.h.

{
    return state && state->vk_bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS;
}

Referenced by d3d12_command_list_has_depth_stencil_view(), d3d12_command_list_update_graphics_pipeline(), d3d12_pipeline_state_get_or_create_pipeline(), d3d12_pipeline_state_has_unknown_dsv_format(), and d3d12_pipeline_state_Release().

d3d12_placed_resource_create()

HRESULT d3d12_placed_resource_create	(	struct d3d12_device *	device,
		struct d3d12_heap *	heap,
		uint64_t	heap_offset,
		const D3D12_RESOURCE_DESC1 *	desc,
		D3D12_RESOURCE_STATES	initial_state,
		const D3D12_CLEAR_VALUE *	optimized_clear_value,
		struct d3d12_resource **	resource
	)

Definition at line 2216 of file resource.c.

{
    struct d3d12_resource *object;
    HRESULT hr;
 
    if (FAILED(hr = d3d12_resource_create(device, &heap->desc.Properties, heap->desc.Flags,
            desc, initial_state, optimized_clear_value, &object)))
        return hr;
 
    if (FAILED(hr = vkd3d_bind_heap_memory(device, object, heap, heap_offset)))
    {
        d3d12_resource_Release(&object->ID3D12Resource2_iface);
        return hr;
    }
 
    TRACE("Created placed resource %p.\n", object);
 
    *resource = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreatePlacedResource(), and d3d12_device_CreatePlacedResource1().

d3d12_query_heap_create()

HRESULT d3d12_query_heap_create	(	struct d3d12_device *	device,
		const D3D12_QUERY_HEAP_DESC *	desc,
		struct d3d12_query_heap **	heap
	)

Definition at line 4568 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    struct d3d12_query_heap *object;
    VkQueryPoolCreateInfo pool_info;
    unsigned int element_count;
    VkResult vr;
    HRESULT hr;
 
    element_count = DIV_ROUND_UP(desc->Count, sizeof(*object->availability_mask) * CHAR_BIT);
    if (!(object = vkd3d_malloc(offsetof(struct d3d12_query_heap, availability_mask[element_count]))))
        return E_OUTOFMEMORY;
 
    object->ID3D12QueryHeap_iface.lpVtbl = &d3d12_query_heap_vtbl;
    object->refcount = 1;
    object->device = device;
    memset(object->availability_mask, 0, element_count * sizeof(*object->availability_mask));
 
    pool_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
    pool_info.pNext = NULL;
    pool_info.flags = 0;
    pool_info.queryCount = desc->Count;
 
    switch (desc->Type)
    {
        case D3D12_QUERY_HEAP_TYPE_OCCLUSION:
            pool_info.queryType = VK_QUERY_TYPE_OCCLUSION;
            pool_info.pipelineStatistics = 0;
            break;
 
        case D3D12_QUERY_HEAP_TYPE_TIMESTAMP:
            pool_info.queryType = VK_QUERY_TYPE_TIMESTAMP;
            pool_info.pipelineStatistics = 0;
            break;
 
        case D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS:
            pool_info.queryType = VK_QUERY_TYPE_PIPELINE_STATISTICS;
            pool_info.pipelineStatistics = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
                    | VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
            break;
 
        case D3D12_QUERY_HEAP_TYPE_SO_STATISTICS:
            if (!device->vk_info.transform_feedback_queries)
            {
                FIXME("Transform feedback queries are not supported by Vulkan implementation.\n");
                vkd3d_free(object);
                return E_NOTIMPL;
            }
 
            pool_info.queryType = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT;
            pool_info.pipelineStatistics = 0;
            break;
 
        default:
            WARN("Invalid query heap type %u.\n", desc->Type);
            vkd3d_free(object);
            return E_INVALIDARG;
    }
 
    if (FAILED(hr = vkd3d_private_store_init(&object->private_store)))
    {
        vkd3d_free(object);
        return hr;
    }
 
    if ((vr = VK_CALL(vkCreateQueryPool(device->vk_device, &pool_info, NULL, &object->vk_query_pool))) < 0)
    {
        WARN("Failed to create Vulkan query pool, vr %d.\n", vr);
        vkd3d_private_store_destroy(&object->private_store);
        vkd3d_free(object);
        return hresult_from_vk_result(vr);
    }
 
    d3d12_device_add_ref(device);
 
    TRACE("Created query heap %p.\n", object);
 
    *heap = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateQueryHeap().

d3d12_query_heap_is_result_available()

static bool d3d12_query_heap_is_result_available ( const struct d3d12_query_heap *  heap, unsigned int  query_index  )

inlinestatic

Definition at line 891 of file vkd3d_private.h.

{
    unsigned int index = query_index / (sizeof(*heap->availability_mask) * CHAR_BIT);
    unsigned int shift = query_index % (sizeof(*heap->availability_mask) * CHAR_BIT);
    return heap->availability_mask[index] & ((uint64_t)1 << shift);
}

Referenced by d3d12_command_list_ResolveQueryData().

d3d12_query_heap_mark_result_as_available()

static void d3d12_query_heap_mark_result_as_available ( struct d3d12_query_heap *  heap, unsigned int  query_index  )

inlinestatic

Definition at line 899 of file vkd3d_private.h.

{
    unsigned int index = query_index / (sizeof(*heap->availability_mask) * CHAR_BIT);
    unsigned int shift = query_index % (sizeof(*heap->availability_mask) * CHAR_BIT);
    heap->availability_mask[index] |= (uint64_t)1 << shift;
}

Referenced by d3d12_command_list_EndQuery().

d3d12_reserved_resource_create()

HRESULT d3d12_reserved_resource_create	(	struct d3d12_device *	device,
		const D3D12_RESOURCE_DESC1 *	desc,
		D3D12_RESOURCE_STATES	initial_state,
		const D3D12_CLEAR_VALUE *	optimized_clear_value,
		struct d3d12_resource **	resource
	)

Definition at line 2240 of file resource.c.

{
    struct d3d12_resource *object;
    HRESULT hr;
 
    if (FAILED(hr = d3d12_resource_create(device, NULL, 0,
            desc, initial_state, optimized_clear_value, &object)))
        return hr;
 
    if (!d3d12_resource_init_tiles(object, device))
    {
        d3d12_resource_Release(&object->ID3D12Resource2_iface);
        return E_OUTOFMEMORY;
    }
 
    TRACE("Created reserved resource %p.\n", object);
 
    *resource = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateReservedResource().

d3d12_resource_desc1_from_desc()

static void d3d12_resource_desc1_from_desc ( D3D12_RESOURCE_DESC1 *  desc1, const D3D12_RESOURCE_DESC *  desc  )

inlinestatic

Definition at line 551 of file vkd3d_private.h.

{
    memcpy(desc1, desc, sizeof(*desc));
    desc1->SamplerFeedbackMipRegion.Width = 0;
    desc1->SamplerFeedbackMipRegion.Height = 0;
    desc1->SamplerFeedbackMipRegion.Depth = 0;
}

Referenced by d3d12_device_CreateCommittedResource(), d3d12_device_CreateCommittedResource1(), d3d12_device_CreatePlacedResource(), d3d12_device_CreateReservedResource(), d3d12_device_get_resource_allocation_info(), d3d12_device_GetCopyableFootprints(), and vkd3d_create_image_resource().

d3d12_resource_desc_get_depth()

static unsigned int d3d12_resource_desc_get_depth ( const D3D12_RESOURCE_DESC1 *  desc, unsigned int  miplevel_idx  )

inlinestatic

Definition at line 1709 of file vkd3d_private.h.

{
    unsigned int d = desc->Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? 1 : desc->DepthOrArraySize;
    return max(1, d >> miplevel_idx);
}

Referenced by compute_image_subresource_size_in_tiles(), d3d12_command_list_clear_uav(), d3d12_command_list_copy_incompatible_texture_region(), d3d12_device_get_copyable_footprints(), d3d12_resource_get_level_box(), d3d12_resource_validate_box(), max_miplevel_count(), and vk_extent_3d_from_d3d12_miplevel().

d3d12_resource_desc_get_height()

static unsigned int d3d12_resource_desc_get_height ( const D3D12_RESOURCE_DESC1 *  desc, unsigned int  miplevel_idx  )

inlinestatic

Definition at line 1703 of file vkd3d_private.h.

{
    return max(1, desc->Height >> miplevel_idx);
}

Referenced by compute_image_subresource_size_in_tiles(), d3d12_command_list_clear_uav(), d3d12_command_list_copy_incompatible_texture_region(), d3d12_device_get_copyable_footprints(), d3d12_dsv_desc_create_dsv(), d3d12_resource_get_level_box(), d3d12_resource_validate_box(), d3d12_rtv_desc_create_rtv(), and vk_extent_3d_from_d3d12_miplevel().

d3d12_resource_desc_get_layer_count()

static unsigned int d3d12_resource_desc_get_layer_count ( const D3D12_RESOURCE_DESC1 *  desc )

inlinestatic

Definition at line 1716 of file vkd3d_private.h.

{
    return desc->Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE3D ? desc->DepthOrArraySize : 1;
}

Referenced by d3d12_command_list_CopyResource(), d3d12_resource_desc_get_sub_resource_count(), and init_default_texture_view_desc().

d3d12_resource_desc_get_sub_resource_count()

static unsigned int d3d12_resource_desc_get_sub_resource_count ( const D3D12_RESOURCE_DESC1 *  desc )

inlinestatic

Definition at line 1721 of file vkd3d_private.h.

{
    return d3d12_resource_desc_get_layer_count(desc) * desc->MipLevels;
}

Referenced by d3d12_command_list_ResourceBarrier(), d3d12_device_get_copyable_footprints(), d3d12_resource_init_tiles(), d3d12_resource_Map(), and d3d12_resource_Unmap().

d3d12_resource_desc_get_width()

static unsigned int d3d12_resource_desc_get_width ( const D3D12_RESOURCE_DESC1 *  desc, unsigned int  miplevel_idx  )

inlinestatic

Definition at line 1697 of file vkd3d_private.h.

{
    return max(1, desc->Width >> miplevel_idx);
}

Referenced by compute_image_subresource_size_in_tiles(), d3d12_command_list_clear_uav(), d3d12_command_list_copy_incompatible_texture_region(), d3d12_device_get_copyable_footprints(), d3d12_dsv_desc_create_dsv(), d3d12_resource_get_level_box(), d3d12_resource_validate_box(), d3d12_rtv_desc_create_rtv(), and vk_extent_3d_from_d3d12_miplevel().

d3d12_resource_get_tiling()

void d3d12_resource_get_tiling	(	struct d3d12_device *	device,
		const struct d3d12_resource *	resource,
		UINT *	total_tile_count,
		D3D12_PACKED_MIP_INFO *	packed_mip_info,
		D3D12_TILE_SHAPE *	standard_tile_shape,
		UINT *	sub_resource_tiling_count,
		UINT	first_sub_resource_tiling,
		D3D12_SUBRESOURCE_TILING *	sub_resource_tilings
	)

Definition at line 1085 of file resource.c.

{
    unsigned int i, subresource, subresource_count, miplevel_idx, count;
    const struct vkd3d_subresource_tile_info *tile_info;
    const VkExtent3D *tile_extent;
 
    tile_extent = &resource->tiles.tile_extent;
 
    if (packed_mip_info)
    {
        packed_mip_info->NumStandardMips = resource->tiles.standard_mip_count;
        packed_mip_info->NumPackedMips = resource->desc.MipLevels - packed_mip_info->NumStandardMips;
        packed_mip_info->NumTilesForPackedMips = !!resource->tiles.packed_mip_tile_count; /* non-zero dummy value */
        packed_mip_info->StartTileIndexInOverallResource = packed_mip_info->NumPackedMips
                ? resource->tiles.subresources[resource->tiles.standard_mip_count].offset : 0;
    }
 
    if (standard_tile_shape)
    {
        /* D3D12 docs say tile shape is cleared to zero if there is no standard mip, but drivers don't to do this. */
        standard_tile_shape->WidthInTexels = tile_extent->width;
        standard_tile_shape->HeightInTexels = tile_extent->height;
        standard_tile_shape->DepthInTexels = tile_extent->depth;
    }
 
    if (total_tile_count)
        *total_tile_count = resource->tiles.total_count;
 
    if (!subresource_tiling_count)
        return;
 
    subresource_count = resource->tiles.subresource_count;
 
    count = subresource_count - min(first_subresource_tiling, subresource_count);
    count = min(count, *subresource_tiling_count);
 
    for (i = 0; i < count; ++i)
    {
        subresource = i + first_subresource_tiling;
        miplevel_idx = subresource % resource->desc.MipLevels;
        if (miplevel_idx >= resource->tiles.standard_mip_count)
        {
            memset(&subresource_tilings[i], 0, sizeof(subresource_tilings[i]));
            subresource_tilings[i].StartTileIndexInOverallResource = D3D12_PACKED_TILE;
            continue;
        }
 
        tile_info = &resource->tiles.subresources[subresource];
        subresource_tilings[i].StartTileIndexInOverallResource = tile_info->offset;
        subresource_tilings[i].WidthInTiles = tile_info->extent.width;
        subresource_tilings[i].HeightInTiles = tile_info->extent.height;
        subresource_tilings[i].DepthInTiles = tile_info->extent.depth;
    }
    *subresource_tiling_count = i;
}

Referenced by d3d12_device_GetResourceTiling().

d3d12_resource_is_buffer()

static bool d3d12_resource_is_buffer ( const struct d3d12_resource *  resource )

inlinestatic

Definition at line 514 of file vkd3d_private.h.

{
    return resource->desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER;
}

Referenced by create_uint_view(), d3d12_command_list_clear_uav(), d3d12_command_list_CopyBufferRegion(), d3d12_command_list_CopyResource(), d3d12_command_list_CopyTextureRegion(), d3d12_command_list_ResolveQueryData(), d3d12_command_list_ResourceBarrier(), d3d12_command_list_SetPredication(), d3d12_desc_create_srv(), d3d12_desc_create_uav(), d3d12_heap_init(), d3d12_resource_destroy(), d3d12_resource_init(), d3d12_resource_init_tiles(), d3d12_resource_ReadFromSubresource(), d3d12_resource_SetName(), d3d12_resource_WriteToSubresource(), vkd3d_bind_heap_memory(), vkd3d_create_buffer_uav(), vkd3d_create_buffer_view_for_resource(), and vkd3d_create_raw_buffer_view().

d3d12_resource_is_cpu_accessible()

bool d3d12_resource_is_cpu_accessible

(

const struct d3d12_resource *

resource

)

Definition at line 1029 of file resource.c.

{
    return resource->heap && is_cpu_accessible_heap(&resource->heap->desc.Properties);
}

Referenced by d3d12_command_list_transition_resource_to_initial_state(), d3d12_resource_Map(), d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

d3d12_resource_is_texture()

static bool d3d12_resource_is_texture ( const struct d3d12_resource *  resource )

inlinestatic

Definition at line 519 of file vkd3d_private.h.

{
    return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER;
}

Referenced by d3d12_command_list_copy_incompatible_texture_region(), d3d12_command_list_CopyResource(), d3d12_command_list_CopyTextureRegion(), d3d12_command_list_ResolveSubresource(), d3d12_command_list_transition_resource_to_initial_state(), d3d12_dsv_desc_create_dsv(), d3d12_resource_Map(), d3d12_resource_validate_heap_properties(), and d3d12_rtv_desc_create_rtv().

d3d12_resource_validate_desc()

HRESULT d3d12_resource_validate_desc	(	const D3D12_RESOURCE_DESC1 *	desc,
		struct d3d12_device *	device
	)

Definition at line 1850 of file resource.c.

{
    const D3D12_MIP_REGION *mip_region = &desc->SamplerFeedbackMipRegion;
    const struct vkd3d_format *format;
 
    switch (desc->Dimension)
    {
        case D3D12_RESOURCE_DIMENSION_BUFFER:
            if (desc->MipLevels != 1)
            {
                WARN("Invalid miplevel count %u for buffer.\n", desc->MipLevels);
                return E_INVALIDARG;
            }
 
            if (desc->Format != DXGI_FORMAT_UNKNOWN || desc->Layout != D3D12_TEXTURE_LAYOUT_ROW_MAJOR
                    || desc->Height != 1 || desc->DepthOrArraySize != 1
                    || desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality != 0
                    || (desc->Alignment != 0 && desc->Alignment != D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT))
            {
                WARN("Invalid parameters for a buffer resource.\n");
                return E_INVALIDARG;
            }
            break;
 
        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
            if (desc->Height != 1)
            {
                WARN("1D texture with a height of %u.\n", desc->Height);
                return E_INVALIDARG;
            }
            /* Fall through. */
        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
            if (!desc->SampleDesc.Count)
            {
                WARN("Invalid sample count 0.\n");
                return E_INVALIDARG;
            }
            if (desc->SampleDesc.Count > 1
                    && !(desc->Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)))
            {
                WARN("Sample count %u invalid without ALLOW_RENDER_TARGET or ALLOW_DEPTH_STENCIL.\n",
                        desc->SampleDesc.Count);
                return E_INVALIDARG;
            }
 
            if (!(format = vkd3d_format_from_d3d12_resource_desc(device, desc, 0)))
            {
                WARN("Invalid format %#x.\n", desc->Format);
                return E_INVALIDARG;
            }
 
            if (desc->Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE)
            {
                if (desc->Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D && !device->vk_info.sparse_residency_3d)
                {
                    WARN("The device does not support tiled 3D images.\n");
                    return E_INVALIDARG;
                }
                if (format->plane_count > 1)
                {
                    WARN("Invalid format %#x. D3D12 does not support multiplanar formats for tiled resources.\n",
                            format->dxgi_format);
                    return E_INVALIDARG;
                }
            }
 
            if (!d3d12_resource_validate_texture_format(desc, format)
                    || !d3d12_resource_validate_texture_alignment(desc, format))
                return E_INVALIDARG;
            break;
 
        default:
            WARN("Invalid resource dimension %#x.\n", desc->Dimension);
            return E_INVALIDARG;
    }
 
    d3d12_validate_resource_flags(desc->Flags);
 
    if (mip_region->Width && mip_region->Height && mip_region->Depth)
    {
        FIXME("Unhandled sampler feedback mip region size (%u, %u, %u).\n", mip_region->Width, mip_region->Height,
                mip_region->Depth);
    }
 
    return S_OK;
}

Referenced by d3d12_device_get_copyable_footprints(), d3d12_device_get_resource1_allocation_info(), d3d12_resource_init(), and vkd3d_get_image_allocation_info().

d3d12_root_signature_create()

HRESULT d3d12_root_signature_create	(	struct d3d12_device *	device,
		const void *	bytecode,
		size_t	bytecode_length,
		struct d3d12_root_signature **	root_signature
	)

Definition at line 1630 of file state.c.

{
    const struct vkd3d_shader_code dxbc = {bytecode, bytecode_length};
    union
    {
        D3D12_VERSIONED_ROOT_SIGNATURE_DESC d3d12;
        struct vkd3d_shader_versioned_root_signature_desc vkd3d;
    } root_signature_desc;
    struct d3d12_root_signature *object;
    HRESULT hr;
    int ret;
 
    if ((ret = vkd3d_parse_root_signature_v_1_0(&dxbc, &root_signature_desc.vkd3d)) < 0)
    {
        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
        return hresult_from_vkd3d_result(ret);
    }
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
    {
        vkd3d_shader_free_root_signature(&root_signature_desc.vkd3d);
        return E_OUTOFMEMORY;
    }
 
    hr = d3d12_root_signature_init(object, device, &root_signature_desc.d3d12.u.Desc_1_0);
    vkd3d_shader_free_root_signature(&root_signature_desc.vkd3d);
    if (FAILED(hr))
    {
        vkd3d_free(object);
        return hr;
    }
 
    TRACE("Created root signature %p.\n", object);
 
    *root_signature = object;
 
    return S_OK;
}

Referenced by d3d12_device_CreateRootSignature(), and d3d12_pipeline_state_init_compute().

d3d12_rtv_desc_create_rtv()

void d3d12_rtv_desc_create_rtv	(	struct d3d12_rtv_desc *	rtv_desc,
		struct d3d12_device *	device,
		struct d3d12_resource *	resource,
		const D3D12_RENDER_TARGET_VIEW_DESC *	desc
	)

Definition at line 3835 of file resource.c.

{
    struct vkd3d_texture_view_desc vkd3d_desc;
    struct vkd3d_view *view;
 
    d3d12_rtv_desc_destroy(rtv_desc, device);
 
    if (!resource)
    {
        FIXME("NULL resource RTV not implemented.\n");
        return;
    }
 
    if (!init_default_texture_view_desc(&vkd3d_desc, resource, desc ? desc->Format : 0))
        return;
 
    vkd3d_desc.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
    if (vkd3d_desc.format->vk_aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT)
    {
        WARN("Trying to create RTV for depth/stencil format %#x.\n", vkd3d_desc.format->dxgi_format);
        return;
    }
 
    if (desc)
    {
        switch (desc->ViewDimension)
        {
            case D3D12_RTV_DIMENSION_TEXTURE2D:
                vkd3d_desc.miplevel_idx = desc->u.Texture2D.MipSlice;
                if (desc->u.Texture2D.PlaneSlice)
                    vkd3d_desc.vk_image_aspect = vk_image_aspect_flags_from_d3d12_plane_slice(resource->format,
                            desc->u.Texture2D.PlaneSlice);
                break;
            case D3D12_RTV_DIMENSION_TEXTURE2DARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.miplevel_idx = desc->u.Texture2DArray.MipSlice;
                vkd3d_desc.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DArray.ArraySize;
                if (desc->u.Texture2DArray.PlaneSlice)
                    vkd3d_desc.vk_image_aspect = vk_image_aspect_flags_from_d3d12_plane_slice(resource->format,
                            desc->u.Texture2DArray.PlaneSlice);
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            case D3D12_RTV_DIMENSION_TEXTURE2DMS:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D;
                break;
            case D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
                vkd3d_desc.layer_count = desc->u.Texture2DMSArray.ArraySize;
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            case D3D12_RTV_DIMENSION_TEXTURE3D:
                vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
                vkd3d_desc.miplevel_idx = desc->u.Texture3D.MipSlice;
                vkd3d_desc.layer_idx = desc->u.Texture3D.FirstWSlice;
                vkd3d_desc.layer_count = desc->u.Texture3D.WSize;
                vkd3d_texture_view_desc_normalise(&vkd3d_desc, &resource->desc);
                break;
            default:
                FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
        }
    }
    else if (resource->desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D)
    {
        vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
        vkd3d_desc.layer_idx = 0;
        vkd3d_desc.layer_count = resource->desc.DepthOrArraySize;
    }
 
    VKD3D_ASSERT(d3d12_resource_is_texture(resource));
 
    if (!vkd3d_create_texture_view(device, VKD3D_DESCRIPTOR_MAGIC_RTV, resource->u.vk_image, &vkd3d_desc, &view))
        return;
 
    rtv_desc->sample_count = vk_samples_from_dxgi_sample_desc(&resource->desc.SampleDesc);
    rtv_desc->format = vkd3d_desc.format;
    rtv_desc->width = d3d12_resource_desc_get_width(&resource->desc, vkd3d_desc.miplevel_idx);
    rtv_desc->height = d3d12_resource_desc_get_height(&resource->desc, vkd3d_desc.miplevel_idx);
    rtv_desc->layer_count = vkd3d_desc.layer_count;
    rtv_desc->view = view;
    rtv_desc->resource = resource;
}

Referenced by d3d12_device_CreateRenderTargetView().

d3d12_rtv_desc_from_cpu_handle()

static struct d3d12_rtv_desc * d3d12_rtv_desc_from_cpu_handle ( D3D12_CPU_DESCRIPTOR_HANDLE  cpu_handle )

inlinestatic

Definition at line 746 of file vkd3d_private.h.

{
    return (struct d3d12_rtv_desc *)cpu_handle.ptr;
}

Referenced by d3d12_command_list_ClearRenderTargetView(), d3d12_command_list_OMSetRenderTargets(), and d3d12_device_CreateRenderTargetView().

debug_cpu_handle()

const char * debug_cpu_handle

(

D3D12_CPU_DESCRIPTOR_HANDLE

handle

)

Definition at line 645 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%#"PRIxPTR"}", (uintptr_t)handle.ptr);
}

Referenced by d3d12_command_list_ClearDepthStencilView(), d3d12_command_list_ClearRenderTargetView(), d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_device_CopyDescriptorsSimple(), d3d12_device_CreateConstantBufferView(), d3d12_device_CreateDepthStencilView(), d3d12_device_CreateRenderTargetView(), d3d12_device_CreateSampler(), d3d12_device_CreateSamplerFeedbackUnorderedAccessView(), d3d12_device_CreateShaderResourceView(), and d3d12_device_CreateUnorderedAccessView().

debug_d3d12_box()

const char * debug_d3d12_box

(

const D3D12_BOX *

box

)

Definition at line 650 of file utils.c.

{
    if (!box)
        return "(null)";
 
    return vkd3d_dbg_sprintf("(%u, %u, %u)-(%u, %u, %u)",
            box->left, box->top, box->front,
            box->right, box->bottom, box->back);
}

Referenced by d3d12_command_list_CopyTextureRegion(), d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

debug_d3d12_shader_component_mapping()

const char * debug_d3d12_shader_component_mapping

(

unsigned int

mapping

)

Definition at line 682 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%s, %s, %s, %s}",
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(0, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(1, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(2, mapping)),
            debug_d3d12_shader_component(D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(3, mapping)));
}

Referenced by d3d12_desc_create_srv().

debug_gpu_handle()

const char * debug_gpu_handle

(

D3D12_GPU_DESCRIPTOR_HANDLE

handle

)

Definition at line 691 of file utils.c.

{
    return vkd3d_dbg_sprintf("{%#"PRIx64"}", handle.ptr);
}

Referenced by d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_command_list_SetComputeRootDescriptorTable(), and d3d12_command_list_SetGraphicsRootDescriptorTable().

debug_ignored_node_mask()

static void debug_ignored_node_mask ( unsigned int  mask )

inlinestatic

Definition at line 1751 of file vkd3d_private.h.

{
    if (mask && mask != 1)
        FIXME("Ignoring node mask 0x%08x.\n", mask);
}

Referenced by d3d12_command_list_create(), d3d12_device_CreateRootSignature(), d3d12_device_GetCustomHeapProperties(), d3d12_device_GetResourceAllocationInfo(), d3d12_device_GetResourceAllocationInfo1(), d3d12_device_GetResourceAllocationInfo2(), and d3d12_heap_init().

debug_vk_extent_3d()

const char * debug_vk_extent_3d

(

VkExtent3D

extent

)

Definition at line 696 of file utils.c.

{
    return vkd3d_dbg_sprintf("(%u, %u, %u)",
            (unsigned int)extent.width,
            (unsigned int)extent.height,
            (unsigned int)extent.depth);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_memory_heap_flags()

const char * debug_vk_memory_heap_flags

(

VkMemoryHeapFlags

flags

)

Definition at line 728 of file utils.c.

{
    char buffer[80];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
    FLAG_TO_STR(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_memory_property_flags()

const char * debug_vk_memory_property_flags

(

VkMemoryPropertyFlags

flags

)

Definition at line 745 of file utils.c.

{
    char buffer[320];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_PROTECTED_BIT)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD)
    FLAG_TO_STR(VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

debug_vk_queue_flags()

const char * debug_vk_queue_flags

(

VkQueueFlags

flags

)

Definition at line 704 of file utils.c.

{
    char buffer[191];
 
    buffer[0] = '\0';
#define FLAG_TO_STR(f) if (flags & f) { strcat(buffer, " | "#f); flags &= ~f; }
    FLAG_TO_STR(VK_QUEUE_GRAPHICS_BIT)
    FLAG_TO_STR(VK_QUEUE_COMPUTE_BIT)
    FLAG_TO_STR(VK_QUEUE_TRANSFER_BIT)
    FLAG_TO_STR(VK_QUEUE_SPARSE_BINDING_BIT)
    FLAG_TO_STR(VK_QUEUE_PROTECTED_BIT)
#undef FLAG_TO_STR
#define FLAG_TO_STR(f, n) if (flags & f) { strcat(buffer, " | "#n); flags &= ~f; }
    FLAG_TO_STR(0x20, VK_QUEUE_VIDEO_DECODE_BIT_KHR)
    FLAG_TO_STR(0x40, VK_QUEUE_VIDEO_ENCODE_BIT_KHR)
#undef FLAG_TO_STR
    if (flags)
        FIXME("Unrecognized flag(s) %#x.\n", flags);
 
    if (!buffer[0])
        return "0";
    return vkd3d_dbg_sprintf("%s", &buffer[3]);
}

Referenced by vkd3d_trace_physical_device().

dsv_attachment_mask()

static unsigned int dsv_attachment_mask ( const struct d3d12_graphics_pipeline_state *  graphics )

inlinestatic

Definition at line 1045 of file vkd3d_private.h.

{
    return 1u << graphics->rt_count;
}

Referenced by d3d12_graphics_pipeline_state_create_render_pass(), d3d12_pipeline_state_get_or_create_pipeline(), d3d12_pipeline_state_has_unknown_dsv_format(), and d3d12_pipeline_state_init_graphics().

hresult_from_errno()

HRESULT hresult_from_errno

(

int

rc

)

Definition at line 768 of file utils.c.

{
    switch (rc)
    {
        case 0:
            return S_OK;
        case ENOMEM:
            return E_OUTOFMEMORY;
        case EINVAL:
            return E_INVALIDARG;
        default:
            FIXME("Unhandled errno %d.\n", rc);
            return E_FAIL;
    }
}

Referenced by vkd3d_create_thread(), and vkd3d_join_thread().

hresult_from_vk_result()

HRESULT hresult_from_vk_result

(

VkResult

vr

)

Definition at line 784 of file utils.c.

{
    switch (vr)
    {
        case VK_SUCCESS:
            return S_OK;
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            WARN("Out of device memory.\n");
            /* fall-through */
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            return E_OUTOFMEMORY;
        default:
            FIXME("Unhandled VkResult %d.\n", vr);
            /* fall-through */
        case VK_ERROR_DEVICE_LOST:
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            return E_FAIL;
    }
}

Referenced by vkd3d_set_vk_object_name().

hresult_from_vkd3d_result()

HRESULT hresult_from_vkd3d_result

(

int

vkd3d_result

)

Definition at line 21 of file error.c.

{
    switch (vkd3d_result)
    {
        case VKD3D_OK:
            return S_OK;
        case VKD3D_ERROR_INVALID_SHADER:
            WARN("Invalid shader.\n");
            /* fall-through */
        case VKD3D_ERROR:
            return E_FAIL;
        case VKD3D_ERROR_OUT_OF_MEMORY:
            return E_OUTOFMEMORY;
        case VKD3D_ERROR_INVALID_ARGUMENT:
            return E_INVALIDARG;
        case VKD3D_ERROR_NOT_IMPLEMENTED:
            return E_NOTIMPL;
        case VKD3D_ERROR_KEY_ALREADY_EXISTS:
            return DXGI_ERROR_ALREADY_EXISTS;
        case VKD3D_ERROR_NOT_FOUND:
            return DXGI_ERROR_NOT_FOUND;
        case VKD3D_ERROR_MORE_DATA:
            return DXGI_ERROR_MORE_DATA;
        default:
            FIXME("Unhandled vkd3d result %d.\n", vkd3d_result);
            return E_FAIL;
    }
}

impl_from_ID3D12Resource()

static struct d3d12_resource * impl_from_ID3D12Resource ( ID3D12Resource *  iface )

inlinestatic

Definition at line 504 of file vkd3d_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d12_resource, ID3D12Resource2_iface);
}

Referenced by d3d12_command_queue_CopyTileMappings(), d3d12_device_GetResourceTiling(), unsafe_impl_from_ID3D12Resource(), vkd3d_resource_decref(), and vkd3d_resource_incref().

impl_from_ID3D12Resource2()

static struct d3d12_resource * impl_from_ID3D12Resource2 ( ID3D12Resource2 *  iface )

inlinestatic

Definition at line 509 of file vkd3d_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d12_resource, ID3D12Resource2_iface);
}

Referenced by d3d12_resource_AddRef(), d3d12_resource_GetDesc(), d3d12_resource_GetDesc1(), d3d12_resource_GetDevice(), d3d12_resource_GetGPUVirtualAddress(), d3d12_resource_GetHeapProperties(), d3d12_resource_GetPrivateData(), d3d12_resource_Map(), d3d12_resource_ReadFromSubresource(), d3d12_resource_Release(), d3d12_resource_SetName(), d3d12_resource_SetPrivateData(), d3d12_resource_SetPrivateDataInterface(), d3d12_resource_Unmap(), and d3d12_resource_WriteToSubresource().

is_valid_feature_level()

bool is_valid_feature_level

(

D3D_FEATURE_LEVEL

feature_level

)

Definition at line 548 of file utils.c.

{
    static const D3D_FEATURE_LEVEL valid_feature_levels[] =
    {
        D3D_FEATURE_LEVEL_12_2,
        D3D_FEATURE_LEVEL_12_1,
        D3D_FEATURE_LEVEL_12_0,
        D3D_FEATURE_LEVEL_11_1,
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1,
        D3D_FEATURE_LEVEL_1_0_CORE,
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(valid_feature_levels); ++i)
    {
        if (valid_feature_levels[i] == feature_level)
            return true;
    }
 
    return false;
}

Referenced by vkd3d_create_device().

is_valid_resource_state()

bool is_valid_resource_state

(

D3D12_RESOURCE_STATES

state

)

Definition at line 590 of file utils.c.

{
    const D3D12_RESOURCE_STATES valid_states =
            D3D12_RESOURCE_STATE_COMMON |
            D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER |
            D3D12_RESOURCE_STATE_INDEX_BUFFER |
            D3D12_RESOURCE_STATE_RENDER_TARGET |
            D3D12_RESOURCE_STATE_UNORDERED_ACCESS |
            D3D12_RESOURCE_STATE_DEPTH_WRITE |
            D3D12_RESOURCE_STATE_DEPTH_READ |
            D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE |
            D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE |
            D3D12_RESOURCE_STATE_STREAM_OUT |
            D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT |
            D3D12_RESOURCE_STATE_COPY_DEST |
            D3D12_RESOURCE_STATE_COPY_SOURCE |
            D3D12_RESOURCE_STATE_RESOLVE_DEST |
            D3D12_RESOURCE_STATE_RESOLVE_SOURCE |
            D3D12_RESOURCE_STATE_GENERIC_READ |
            D3D12_RESOURCE_STATE_PRESENT |
            D3D12_RESOURCE_STATE_PREDICATION;
 
    if (state & ~valid_states)
    {
        WARN("Invalid resource states %#x.\n", state & ~valid_states);
        return false;
    }
 
    /* Exactly one bit must be set for write states. */
    if (is_write_resource_state(state) && !is_power_of_two(state))
    {
        WARN("Write state cannot be mixed with other states: %#x.\n", state);
        return false;
    }
 
    return true;
}

Referenced by d3d12_command_list_ResourceBarrier(), d3d12_find_ds_multiplanar_transition(), and d3d12_resource_init().

is_write_resource_state()

bool is_write_resource_state

(

D3D12_RESOURCE_STATES

state

)

Definition at line 575 of file utils.c.

{
    return state & (D3D12_RESOURCE_STATE_RENDER_TARGET
            | D3D12_RESOURCE_STATE_UNORDERED_ACCESS
            | D3D12_RESOURCE_STATE_DEPTH_WRITE
            | D3D12_RESOURCE_STATE_STREAM_OUT
            | D3D12_RESOURCE_STATE_COPY_DEST
            | D3D12_RESOURCE_STATE_RESOLVE_DEST);
}

Referenced by is_valid_resource_state(), and vk_barrier_parameters_from_d3d12_resource_state().

return_interface()

HRESULT return_interface	(	void *	iface,
		REFIID	iface_iid,
		REFIID	requested_iid,
		void **	object
	)

Definition at line 628 of file utils.c.

{
    IUnknown *unknown = iface;
    HRESULT hr;
 
    if (IsEqualGUID(iface_iid, requested_iid))
    {
        *object = unknown;
        return S_OK;
    }
 
    hr = IUnknown_QueryInterface(unknown, requested_iid, object);
    IUnknown_Release(unknown);
    return hr;
}

Referenced by d3d12_device_CreateCommandAllocator(), d3d12_device_CreateCommandList(), d3d12_device_CreateCommandQueue(), d3d12_device_CreateCommandSignature(), d3d12_device_CreateCommittedResource(), d3d12_device_CreateCommittedResource1(), d3d12_device_CreateCommittedResource2(), d3d12_device_CreateComputePipelineState(), d3d12_device_CreateDescriptorHeap(), d3d12_device_CreateFence(), d3d12_device_CreateGraphicsPipelineState(), d3d12_device_CreateHeap(), d3d12_device_CreateHeap1(), d3d12_device_CreatePipelineState(), d3d12_device_CreatePlacedResource(), d3d12_device_CreatePlacedResource1(), d3d12_device_CreateQueryHeap(), d3d12_device_CreateReservedResource(), d3d12_device_CreateRootSignature(), vkd3d_create_device(), vkd3d_create_root_signature_deserializer(), and vkd3d_create_versioned_root_signature_deserializer().

unsafe_impl_from_ID3D12CommandSignature()

struct d3d12_command_signature * unsafe_impl_from_ID3D12CommandSignature

(

ID3D12CommandSignature *

iface

)

Definition at line 7627 of file command.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_command_signature_vtbl);
    return CONTAINING_RECORD(iface, struct d3d12_command_signature, ID3D12CommandSignature_iface);
}

Referenced by d3d12_command_list_ExecuteIndirect().

unsafe_impl_from_ID3D12Device9()

void struct d3d12_device * unsafe_impl_from_ID3D12Device9

(

ID3D12Device9 *

iface

)

Definition at line 5398 of file device.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_device_vtbl);
    return impl_from_ID3D12Device9(iface);
}

Referenced by vkd3d_create_image_resource().

unsafe_impl_from_ID3D12Heap()

struct d3d12_heap * unsafe_impl_from_ID3D12Heap

(

ID3D12Heap *

iface

)

Definition at line 442 of file resource.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_heap_vtbl);
    return impl_from_ID3D12Heap(iface);
}

Referenced by d3d12_command_queue_UpdateTileMappings(), d3d12_device_CreatePlacedResource(), and d3d12_device_CreatePlacedResource1().

unsafe_impl_from_ID3D12PipelineState()

struct d3d12_pipeline_state * unsafe_impl_from_ID3D12PipelineState

(

ID3D12PipelineState *

iface

)

Definition at line 2242 of file state.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_pipeline_state_vtbl);
    return impl_from_ID3D12PipelineState(iface);
}

Referenced by d3d12_command_list_SetPipelineState().

unsafe_impl_from_ID3D12QueryHeap()

struct d3d12_query_heap * unsafe_impl_from_ID3D12QueryHeap

(

ID3D12QueryHeap *

iface

)

Definition at line 4560 of file resource.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_query_heap_vtbl);
    return impl_from_ID3D12QueryHeap(iface);
}

Referenced by d3d12_command_list_BeginQuery(), d3d12_command_list_EndQuery(), and d3d12_command_list_ResolveQueryData().

unsafe_impl_from_ID3D12Resource()

struct d3d12_resource * unsafe_impl_from_ID3D12Resource

(

ID3D12Resource *

iface

)

Definition at line 1770 of file resource.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == (ID3D12ResourceVtbl *)&d3d12_resource_vtbl);
    return impl_from_ID3D12Resource(iface);
}

Referenced by d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_command_list_CopyBufferRegion(), d3d12_command_list_CopyResource(), d3d12_command_list_CopyTextureRegion(), d3d12_command_list_ExecuteIndirect(), d3d12_command_list_ResolveQueryData(), d3d12_command_list_ResolveSubresource(), d3d12_command_list_ResourceBarrier(), d3d12_command_list_SetPredication(), d3d12_command_queue_UpdateTileMappings(), d3d12_device_CreateDepthStencilView(), d3d12_device_CreateRenderTargetView(), d3d12_device_CreateShaderResourceView(), and d3d12_device_CreateUnorderedAccessView().

unsafe_impl_from_ID3D12RootSignature()

struct d3d12_root_signature * unsafe_impl_from_ID3D12RootSignature

(

ID3D12RootSignature *

iface

)

Definition at line 193 of file state.c.

{
    if (!iface)
        return NULL;
    VKD3D_ASSERT(iface->lpVtbl == &d3d12_root_signature_vtbl);
    return impl_from_ID3D12RootSignature(iface);
}

Referenced by d3d12_command_list_SetComputeRootSignature(), d3d12_command_list_SetGraphicsRootSignature(), d3d12_pipeline_state_init_compute(), and d3d12_pipeline_state_init_graphics().

vk_compare_op_from_d3d12()

VkCompareOp vk_compare_op_from_d3d12

(

D3D12_COMPARISON_FUNC

op

)

Definition at line 2764 of file state.c.

{
    switch (op)
    {
        case D3D12_COMPARISON_FUNC_NEVER:
            return VK_COMPARE_OP_NEVER;
        case D3D12_COMPARISON_FUNC_LESS:
            return VK_COMPARE_OP_LESS;
        case D3D12_COMPARISON_FUNC_EQUAL:
            return VK_COMPARE_OP_EQUAL;
        case D3D12_COMPARISON_FUNC_LESS_EQUAL:
            return VK_COMPARE_OP_LESS_OR_EQUAL;
        case D3D12_COMPARISON_FUNC_GREATER:
            return VK_COMPARE_OP_GREATER;
        case D3D12_COMPARISON_FUNC_NOT_EQUAL:
            return VK_COMPARE_OP_NOT_EQUAL;
        case D3D12_COMPARISON_FUNC_GREATER_EQUAL:
            return VK_COMPARE_OP_GREATER_OR_EQUAL;
        case D3D12_COMPARISON_FUNC_ALWAYS:
            return VK_COMPARE_OP_ALWAYS;
        default:
            FIXME("Unhandled compare op %#x.\n", op);
            return VK_COMPARE_OP_NEVER;
    }
}

Referenced by d3d12_create_sampler(), ds_desc_from_d3d12(), and vk_stencil_op_state_from_d3d12().

vk_prepend_struct()

static void vk_prepend_struct ( void *  header, void *  structure  )

inlinestatic

Definition at line 1773 of file vkd3d_private.h.

{
    VkBaseOutStructure *vk_header = header, *vk_structure = structure;
 
    vk_structure->pNext = vk_header->pNext;
    vk_header->pNext = vk_structure;
}

Referenced by rs_depth_clip_info_from_d3d12(), rs_stream_info_from_d3d12(), and vkd3d_chain_physical_device_info_structures().

vk_samples_from_dxgi_sample_desc()

VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc

(

const DXGI_SAMPLE_DESC *

desc

)

Definition at line 641 of file resource.c.

{
    VkSampleCountFlagBits vk_samples;
 
    if ((vk_samples = vk_samples_from_sample_count(desc->Count)))
        return vk_samples;
 
    FIXME("Unhandled sample count %u.\n", desc->Count);
    return VK_SAMPLE_COUNT_1_BIT;
}

Referenced by d3d12_dsv_desc_create_dsv(), d3d12_pipeline_state_init_graphics(), d3d12_rtv_desc_create_rtv(), and vkd3d_create_image().

vk_samples_from_sample_count()

VkSampleCountFlagBits vk_samples_from_sample_count

(

unsigned int

sample_count

)

Definition at line 618 of file resource.c.

{
    switch (sample_count)
    {
        case 1:
            return VK_SAMPLE_COUNT_1_BIT;
        case 2:
            return VK_SAMPLE_COUNT_2_BIT;
        case 4:
            return VK_SAMPLE_COUNT_4_BIT;
        case 8:
            return VK_SAMPLE_COUNT_8_BIT;
        case 16:
            return VK_SAMPLE_COUNT_16_BIT;
        case 32:
            return VK_SAMPLE_COUNT_32_BIT;
        case 64:
            return VK_SAMPLE_COUNT_64_BIT;
        default:
            return 0;
    }
}

Referenced by d3d12_device_check_multisample_quality_levels(), and vk_samples_from_dxgi_sample_desc().

vkd3d_allocate_buffer_memory()

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,
		uint32_t *	vk_memory_type,
		VkDeviceSize *	vk_memory_size
	)

Definition at line 155 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkMemoryDedicatedAllocateInfo *dedicated_allocation = NULL;
    VkMemoryDedicatedRequirements dedicated_requirements;
    VkMemoryDedicatedAllocateInfo dedicated_info;
    VkMemoryRequirements2 memory_requirements2;
    VkMemoryRequirements *memory_requirements;
    VkBufferMemoryRequirementsInfo2 info;
    VkResult vr;
    HRESULT hr;
 
    memory_requirements = &memory_requirements2.memoryRequirements;
 
    if (device->vk_info.KHR_dedicated_allocation)
    {
        info.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
        info.pNext = NULL;
        info.buffer = vk_buffer;
 
        dedicated_requirements.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
        dedicated_requirements.pNext = NULL;
 
        memory_requirements2.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
        memory_requirements2.pNext = &dedicated_requirements;
 
        VK_CALL(vkGetBufferMemoryRequirements2KHR(device->vk_device, &info, &memory_requirements2));
 
        if (dedicated_requirements.prefersDedicatedAllocation)
        {
            dedicated_allocation = &dedicated_info;
 
            dedicated_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
            dedicated_info.pNext = NULL;
            dedicated_info.image = VK_NULL_HANDLE;
            dedicated_info.buffer = vk_buffer;
        }
    }
    else
    {
        VK_CALL(vkGetBufferMemoryRequirements(device->vk_device, vk_buffer, memory_requirements));
    }
 
    if (FAILED(hr = vkd3d_allocate_device_memory(device, heap_properties, heap_flags,
            memory_requirements, dedicated_allocation, vk_memory, vk_memory_type)))
        return hr;
 
    if ((vr = VK_CALL(vkBindBufferMemory(device->vk_device, vk_buffer, *vk_memory, 0))) < 0)
    {
        WARN("Failed to bind memory, vr %d.\n", vr);
        VK_CALL(vkFreeMemory(device->vk_device, *vk_memory, NULL));
        *vk_memory = VK_NULL_HANDLE;
    }
 
    if (vk_memory_size)
        *vk_memory_size = memory_requirements->size;
 
    return hresult_from_vk_result(vr);
}

Referenced by d3d12_command_list_allocate_transfer_buffer(), d3d12_heap_init(), and vkd3d_init_null_resources().

vkd3d_cleanup_format_info()

void vkd3d_cleanup_format_info

(

struct d3d12_device *

device

)

Definition at line 414 of file utils.c.

{
    vkd3d_cleanup_depth_stencil_formats(device);
    vkd3d_cleanup_format_compatibility_lists(device);
}

Referenced by d3d12_device_init(), and d3d12_device_Release().

vkd3d_compute_workgroup_count()

static unsigned int vkd3d_compute_workgroup_count ( unsigned int  thread_count, unsigned int  workgroup_size  )

inlinestatic

Definition at line 1726 of file vkd3d_private.h.

{
    return (thread_count + workgroup_size - 1) / workgroup_size;
}

Referenced by d3d12_command_list_clear_uav().

vkd3d_create_buffer()

HRESULT vkd3d_create_buffer	(	struct d3d12_device *	device,
		const D3D12_HEAP_PROPERTIES *	heap_properties,
		D3D12_HEAP_FLAGS	heap_flags,
		const D3D12_RESOURCE_DESC1 *	desc,
		VkBuffer *	vk_buffer
	)

Definition at line 652 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    const bool sparse_resource = !heap_properties;
    VkBufferCreateInfo buffer_info;
    D3D12_HEAP_TYPE heap_type;
    VkResult vr;
 
    heap_type = heap_properties ? heap_properties->Type : D3D12_HEAP_TYPE_DEFAULT;
 
    buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    buffer_info.pNext = NULL;
    buffer_info.flags = 0;
    buffer_info.size = desc->Width;
 
    if (sparse_resource)
    {
        buffer_info.flags |= VK_BUFFER_CREATE_SPARSE_BINDING_BIT;
        if (device->vk_info.sparse_properties.residencyNonResidentStrict)
            buffer_info.flags |= VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT;
    }
 
    buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT
            | VK_BUFFER_USAGE_TRANSFER_DST_BIT
            | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
            | VK_BUFFER_USAGE_INDEX_BUFFER_BIT
            | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
            | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
 
    if (device->vk_info.EXT_conditional_rendering)
        buffer_info.usage |= VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT;
 
    if (heap_type == D3D12_HEAP_TYPE_DEFAULT && device->vk_info.EXT_transform_feedback)
    {
        buffer_info.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
                | VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT;
    }
 
    if (heap_type == D3D12_HEAP_TYPE_UPLOAD)
        buffer_info.usage &= ~VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    else if (heap_type == D3D12_HEAP_TYPE_READBACK)
        buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
 
    if (desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS)
        buffer_info.usage |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
    if (!(desc->Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE))
        buffer_info.usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
 
    /* Buffers always have properties of D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS. */
    if (desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS)
    {
        WARN("D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS cannot be set for buffers.\n");
        return E_INVALIDARG;
    }
 
    if (device->queue_family_count > 1)
    {
        buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT;
        buffer_info.queueFamilyIndexCount = device->queue_family_count;
        buffer_info.pQueueFamilyIndices = device->queue_family_indices;
    }
    else
    {
        buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        buffer_info.queueFamilyIndexCount = 0;
        buffer_info.pQueueFamilyIndices = NULL;
    }
 
    if (desc->Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL))
        FIXME("Unsupported resource flags %#x.\n", desc->Flags);
 
    if ((vr = VK_CALL(vkCreateBuffer(device->vk_device, &buffer_info, NULL, vk_buffer))) < 0)
    {
        WARN("Failed to create Vulkan buffer, vr %d.\n", vr);
        *vk_buffer = VK_NULL_HANDLE;
    }
 
    return hresult_from_vk_result(vr);
}

Referenced by d3d12_command_list_allocate_transfer_buffer(), d3d12_resource_init(), and vkd3d_init_null_resources().

vkd3d_create_buffer_view()

bool vkd3d_create_buffer_view	(	struct d3d12_device *	device,
		uint32_t	magic,
		VkBuffer	vk_buffer,
		const struct vkd3d_format *	format,
		VkDeviceSize	offset,
		VkDeviceSize	size,
		struct vkd3d_view **	view
	)

Definition at line 2792 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkBufferView vk_view = VK_NULL_HANDLE;
    struct vkd3d_view *object;
 
    if (vk_buffer && !vkd3d_create_vk_buffer_view(device, vk_buffer, format, offset, size, &vk_view))
        return false;
 
    if (!(object = vkd3d_view_create(magic, magic == VKD3D_DESCRIPTOR_MAGIC_UAV
            ? VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER : VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
            VKD3D_VIEW_TYPE_BUFFER, device)))
    {
        VK_CALL(vkDestroyBufferView(device->vk_device, vk_view, NULL));
        return false;
    }
 
    object->v.u.vk_buffer_view = vk_view;
    object->v.format = format;
    object->v.info.buffer.offset = offset;
    object->v.info.buffer.size = size;
    *view = object;
    return true;
}

Referenced by create_uint_view(), vkd3d_create_buffer_view_for_resource(), vkd3d_create_null_srv(), and vkd3d_create_null_uav().

vkd3d_create_raw_buffer_view()

bool vkd3d_create_raw_buffer_view	(	struct d3d12_device *	device,
		D3D12_GPU_VIRTUAL_ADDRESS	gpu_address,
		D3D12_ROOT_PARAMETER_TYPE	parameter_type,
		VkBufferView *	vk_buffer_view
	)

Definition at line 3613 of file resource.c.

{
    const struct vkd3d_format *format;
    struct d3d12_resource *resource;
 
    format = vkd3d_get_format(device, DXGI_FORMAT_R32_UINT, false);
 
    if (!gpu_address)
    {
        if (device->vk_info.EXT_robustness2)
        {
            *vk_buffer_view = VK_NULL_HANDLE;
            return true;
        }
        WARN("Creating null buffer view.\n");
        return vkd3d_create_vk_buffer_view(device, parameter_type == D3D12_ROOT_PARAMETER_TYPE_UAV
                ? device->null_resources.vk_storage_buffer : device->null_resources.vk_buffer,
                format, 0, VK_WHOLE_SIZE, vk_buffer_view);
    }
 
    resource = vkd3d_gpu_va_allocator_dereference(&device->gpu_va_allocator, gpu_address);
    VKD3D_ASSERT(d3d12_resource_is_buffer(resource));
    return vkd3d_create_vk_buffer_view(device, resource->u.vk_buffer, format,
            gpu_address - resource->gpu_address, VK_WHOLE_SIZE, vk_buffer_view);
}

Referenced by d3d12_command_list_set_root_descriptor().

vkd3d_create_static_sampler()

HRESULT vkd3d_create_static_sampler	(	struct d3d12_device *	device,
		const D3D12_STATIC_SAMPLER_DESC *	desc,
		VkSampler *	vk_sampler
	)

Definition at line 3814 of file resource.c.

{
    VkResult vr;
 
    vr = d3d12_create_sampler(device, desc->Filter, desc->AddressU, desc->AddressV,
            desc->AddressW, desc->MipLODBias, desc->MaxAnisotropy, desc->ComparisonFunc,
            desc->BorderColor, desc->MinLOD, desc->MaxLOD, vk_sampler);
    return hresult_from_vk_result(vr);
}

Referenced by d3d12_root_signature_init_static_samplers().

vkd3d_create_texture_view()

bool vkd3d_create_texture_view	(	struct d3d12_device *	device,
		uint32_t	magic,
		VkImage	vk_image,
		const struct vkd3d_texture_view_desc *	desc,
		struct vkd3d_view **	view
	)

Definition at line 3082 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    const struct vkd3d_format *format = desc->format;
    VkImageViewUsageCreateInfoKHR usage_desc;
    struct VkImageViewCreateInfo view_desc;
    VkImageView vk_view = VK_NULL_HANDLE;
    struct vkd3d_view *object;
    VkResult vr;
 
    if (vk_image)
    {
        view_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        view_desc.pNext = NULL;
        view_desc.flags = 0;
        view_desc.image = vk_image;
        view_desc.viewType = desc->view_type;
        view_desc.format = format->vk_format;
        vkd3d_set_view_swizzle_for_format(&view_desc.components, format, desc->allowed_swizzle);
        if (desc->allowed_swizzle)
            vk_component_mapping_compose(&view_desc.components, &desc->components);
        view_desc.subresourceRange.aspectMask = desc->vk_image_aspect;
        view_desc.subresourceRange.baseMipLevel = desc->miplevel_idx;
        view_desc.subresourceRange.levelCount = desc->miplevel_count;
        view_desc.subresourceRange.baseArrayLayer = desc->layer_idx;
        view_desc.subresourceRange.layerCount = desc->layer_count;
        if (device->vk_info.KHR_maintenance2)
        {
            usage_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
            usage_desc.pNext = NULL;
            usage_desc.usage = desc->usage;
            view_desc.pNext = &usage_desc;
        }
        if ((vr = VK_CALL(vkCreateImageView(device->vk_device, &view_desc, NULL, &vk_view))) < 0)
        {
            WARN("Failed to create Vulkan image view, vr %d.\n", vr);
            return false;
        }
    }
 
    if (!(object = vkd3d_view_create(magic, magic == VKD3D_DESCRIPTOR_MAGIC_UAV ? VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
            : VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VKD3D_VIEW_TYPE_IMAGE, device)))
    {
        VK_CALL(vkDestroyImageView(device->vk_device, vk_view, NULL));
        return false;
    }
 
    object->v.u.vk_image_view = vk_view;
    object->v.format = format;
    object->v.info.texture.vk_view_type = desc->view_type;
    object->v.info.texture.miplevel_idx = desc->miplevel_idx;
    object->v.info.texture.layer_idx = desc->layer_idx;
    object->v.info.texture.layer_count = desc->layer_count;
    *view = object;
    return true;
}

Referenced by create_uint_view(), d3d12_desc_create_srv(), d3d12_dsv_desc_create_dsv(), d3d12_rtv_desc_create_rtv(), vkd3d_create_null_srv(), vkd3d_create_null_uav(), and vkd3d_create_texture_uav().

vkd3d_create_thread()

HRESULT vkd3d_create_thread	(	struct vkd3d_instance *	instance,
		PFN_vkd3d_thread	thread_main,
		void *	data,
		union vkd3d_thread_handle *	thread
	)

Definition at line 5620 of file device.c.

{
    HRESULT hr = S_OK;
 
    if (instance->create_thread)
    {
        if (!(thread->handle = instance->create_thread(thread_main, data)))
        {
            ERR("Failed to create thread.\n");
            hr = E_FAIL;
        }
    }
    else
    {
#ifdef _WIN32
        struct thread_data *thread_data;
 
        if (!(thread_data = vkd3d_malloc(sizeof(*thread_data))))
            return E_OUTOFMEMORY;
 
        thread_data->main_pfn = thread_main;
        thread_data->data = data;
        if (!(thread->handle = CreateThread(NULL, 0, call_thread_main, thread_data, 0, NULL)))
        {
            ERR("Failed to create thread, error %lu.\n", GetLastError());
            vkd3d_free(thread_data);
            hr = E_FAIL;
        }
#else
        int rc;
 
        if ((rc = pthread_create(&thread->pthread, NULL, thread_main, data)))
        {
            ERR("Failed to create thread, error %d.\n", rc);
            hr = hresult_from_errno(rc);
        }
#endif
    }
 
    return hr;
}

Referenced by d3d12_device_init(), and vkd3d_fence_worker_start().

vkd3d_create_timeline_semaphore()

VkResult vkd3d_create_timeline_semaphore	(	const struct d3d12_device *	device,
		uint64_t	initial_value,
		VkSemaphore *	timeline_semaphore
	)

Definition at line 1239 of file command.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkSemaphoreTypeCreateInfoKHR type_info;
    VkSemaphoreCreateInfo info;
 
    info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
    info.pNext = &type_info;
    info.flags = 0;
 
    type_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR;
    type_info.pNext = NULL;
    type_info.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE_KHR;
    type_info.initialValue = initial_value;
 
    return VK_CALL(vkCreateSemaphore(device->vk_device, &info, NULL, timeline_semaphore));
}

Referenced by d3d12_fence_init().

vkd3d_destroy_null_resources()

void vkd3d_destroy_null_resources	(	struct vkd3d_null_resources *	null_resources,
		struct d3d12_device *	device
	)

Definition at line 4965 of file resource.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
 
    VK_CALL(vkDestroyBuffer(device->vk_device, null_resources->vk_buffer, NULL));
    VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_buffer_memory, NULL));
 
    VK_CALL(vkDestroyBuffer(device->vk_device, null_resources->vk_storage_buffer, NULL));
    VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_storage_buffer_memory, NULL));
 
    VK_CALL(vkDestroyImage(device->vk_device, null_resources->vk_2d_image, NULL));
    VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_2d_image_memory, NULL));
 
    VK_CALL(vkDestroyImage(device->vk_device, null_resources->vk_2d_storage_image, NULL));
    VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_2d_storage_image_memory, NULL));
 
    memset(null_resources, 0, sizeof(*null_resources));
}

Referenced by d3d12_device_init(), d3d12_device_Release(), and vkd3d_init_null_resources().

vkd3d_find_uint_format()

const struct vkd3d_format * vkd3d_find_uint_format	(	const struct d3d12_device *	device,
		DXGI_FORMAT	dxgi_format
	)

Definition at line 465 of file utils.c.

{
    DXGI_FORMAT typeless_format = DXGI_FORMAT_UNKNOWN;
    const struct vkd3d_format *vkd3d_format;
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        if (vkd3d_format_compatibility_info[i].format == dxgi_format)
        {
            typeless_format = vkd3d_format_compatibility_info[i].typeless_format;
            break;
        }
    }
 
    if (!typeless_format)
        return NULL;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_format_compatibility_info); ++i)
    {
        if (vkd3d_format_compatibility_info[i].typeless_format != typeless_format)
            continue;
 
        vkd3d_format = vkd3d_get_format(device, vkd3d_format_compatibility_info[i].format, false);
        if (vkd3d_format->type == VKD3D_FORMAT_TYPE_UINT)
            return vkd3d_format;
    }
 
    return NULL;
}

Referenced by create_uint_view().

vkd3d_format_copy_data()

void vkd3d_format_copy_data	(	const struct vkd3d_format *	format,
		const uint8_t *	src,
		unsigned int	src_row_pitch,
		unsigned int	src_slice_pitch,
		uint8_t *	dst,
		unsigned int	dst_row_pitch,
		unsigned int	dst_slice_pitch,
		unsigned int	w,
		unsigned int	h,
		unsigned int	d
	)

Definition at line 496 of file utils.c.

{
    unsigned int row_block_count, row_count, row_size, slice, row;
    unsigned int slice_count = d;
    const uint8_t *src_row;
    uint8_t *dst_row;
 
    row_block_count = (w + format->block_width - 1) / format->block_width;
    row_count = (h + format->block_height - 1) / format->block_height;
    row_size = row_block_count * format->byte_count * format->block_byte_count;
 
    for (slice = 0; slice < slice_count; ++slice)
    {
        for (row = 0; row < row_count; ++row)
        {
            src_row = &src[slice * src_slice_pitch + row * src_row_pitch];
            dst_row = &dst[slice * dst_slice_pitch + row * dst_row_pitch];
            memcpy(dst_row, src_row, row_size);
        }
    }
}

Referenced by d3d12_resource_ReadFromSubresource(), and d3d12_resource_WriteToSubresource().

vkd3d_format_from_d3d12_resource_desc()

static const struct vkd3d_format * vkd3d_format_from_d3d12_resource_desc ( const struct d3d12_device *  device, const D3D12_RESOURCE_DESC1 *  desc, DXGI_FORMAT  view_format  )

inlinestatic

Definition at line 1685 of file vkd3d_private.h.

{
    return vkd3d_get_format(device, view_format ? view_format : desc->Format,
            desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL);
}

Referenced by d3d12_command_list_CopyTextureRegion(), d3d12_command_list_ResolveSubresource(), d3d12_device_get_copyable_footprints(), d3d12_resource_init(), d3d12_resource_validate_desc(), init_default_texture_view_desc(), vkd3d_create_buffer_view_for_resource(), vkd3d_create_image(), and vkd3d_create_image_resource().

vkd3d_format_get_data_offset()

static size_t vkd3d_format_get_data_offset ( const struct vkd3d_format *  format, unsigned int  row_pitch, unsigned int  slice_pitch, unsigned int  x, unsigned int  y, unsigned int  z  )

inlinestatic

Definition at line 1660 of file vkd3d_private.h.

{
    return z * slice_pitch
            + (y / format->block_height) * row_pitch
            + (x / format->block_width) * format->byte_count * format->block_byte_count;
}

Referenced by d3d12_resource_ReadFromSubresource(), d3d12_resource_WriteToSubresource(), vk_buffer_image_copy_from_d3d12(), and vk_image_buffer_copy_from_d3d12().

vkd3d_format_is_compressed()

static bool vkd3d_format_is_compressed ( const struct vkd3d_format *  format )

inlinestatic

Definition at line 1669 of file vkd3d_private.h.

{
    return format->block_byte_count != 1;
}

Referenced by d3d12_command_list_copy_incompatible_texture_region(), d3d12_resource_validate_texture_format(), vkd3d_create_texture_uav(), vkd3d_create_vk_buffer_view(), and vkd3d_get_required_texel_buffer_alignment().

vkd3d_get_format()

const struct vkd3d_format * vkd3d_get_format	(	const struct d3d12_device *	device,
		DXGI_FORMAT	dxgi_format,
		bool	depth_stencil
	)

Definition at line 442 of file utils.c.

{
    const struct vkd3d_format *format;
    unsigned int i;
 
    if (depth_stencil && (format = vkd3d_get_depth_stencil_format(device, dxgi_format)))
        return format;
 
    for (i = 0; i < ARRAY_SIZE(vkd3d_formats); ++i)
    {
        if (vkd3d_formats[i].dxgi_format == dxgi_format)
            return &vkd3d_formats[i];
    }
 
    /* Do not check VkPhysicalDevice4444FormatsFeaturesEXT because apps
     * should query format support, which returns more detailed info. */
    if (dxgi_format == format_b4g4r4a4.dxgi_format && device->vk_info.EXT_4444_formats)
        return &format_b4g4r4a4;
 
    return NULL;
}

Referenced by compute_input_layout_offsets(), d3d12_device_check_multisample_quality_levels(), d3d12_device_CheckFeatureSupport(), d3d12_device_supports_typed_uav_load_additional_formats(), d3d12_pipeline_state_init_graphics(), vkd3d_create_buffer_uav(), vkd3d_create_buffer_view_for_resource(), vkd3d_create_null_srv(), vkd3d_create_null_uav(), vkd3d_create_raw_buffer_view(), vkd3d_find_uint_format(), vkd3d_fixup_clear_uav_uint_colour(), vkd3d_format_from_d3d12_resource_desc(), and vkd3d_get_vk_format().

vkd3d_get_image_allocation_info()

HRESULT vkd3d_get_image_allocation_info	(	struct d3d12_device *	device,
		const D3D12_RESOURCE_DESC1 *	desc,
		struct vkd3d_resource_allocation_info *	allocation_info
	)

Definition at line 942 of file resource.c.

{
    static const D3D12_HEAP_PROPERTIES heap_properties = {D3D12_HEAP_TYPE_DEFAULT};
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    D3D12_RESOURCE_DESC1 validated_desc;
    VkMemoryRequirements requirements;
    VkImage vk_image;
    bool tiled;
    HRESULT hr;
 
    VKD3D_ASSERT(desc->Dimension != D3D12_RESOURCE_DIMENSION_BUFFER);
    VKD3D_ASSERT(d3d12_resource_validate_desc(desc, device) == S_OK);
 
    if (!desc->MipLevels)
    {
        validated_desc = *desc;
        validated_desc.MipLevels = max_miplevel_count(desc);
        desc = &validated_desc;
    }
 
    tiled = desc->Layout == D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE;
 
    /* XXX: We have to create an image to get its memory requirements. */
    if (SUCCEEDED(hr = vkd3d_create_image(device, tiled ? NULL : &heap_properties, 0, desc, NULL, &vk_image)))
    {
        VK_CALL(vkGetImageMemoryRequirements(device->vk_device, vk_image, &requirements));
        VK_CALL(vkDestroyImage(device->vk_device, vk_image, NULL));
 
        allocation_info->size_in_bytes = requirements.size;
        allocation_info->alignment = requirements.alignment;
    }
 
    return hr;
}

Referenced by d3d12_device_get_resource1_allocation_info(), and d3d12_is_64k_msaa_supported().

vkd3d_get_private_data()

HRESULT vkd3d_get_private_data	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		unsigned int *	out_size,
		void *	out
	)

Definition at line 994 of file utils.c.

{
    const struct vkd3d_private_data *data;
    HRESULT hr = S_OK;
    unsigned int size;
 
    if (!out_size)
        return E_INVALIDARG;
 
    vkd3d_mutex_lock(&store->mutex);
 
    if (!(data = vkd3d_private_store_get_private_data(store, tag)))
    {
        *out_size = 0;
        hr = DXGI_ERROR_NOT_FOUND;
        goto done;
    }
 
    size = *out_size;
    *out_size = data->size;
    if (!out)
        goto done;
 
    if (size < data->size)
    {
        hr = DXGI_ERROR_MORE_DATA;
        goto done;
    }
 
    if (data->is_object)
        IUnknown_AddRef(data->u.object);
    memcpy(out, data->u.data, data->size);
 
done:
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_GetPrivateData(), d3d12_command_allocator_GetPrivateData(), d3d12_command_list_GetPrivateData(), d3d12_command_queue_GetPrivateData(), d3d12_command_signature_GetPrivateData(), d3d12_descriptor_heap_GetPrivateData(), d3d12_device_GetPrivateData(), d3d12_fence_GetPrivateData(), d3d12_heap_GetPrivateData(), d3d12_pipeline_state_GetPrivateData(), d3d12_query_heap_GetPrivateData(), d3d12_resource_GetPrivateData(), and d3d12_root_signature_GetPrivateData().

vkd3d_get_program_name()

bool vkd3d_get_program_name

(

char

program_name[PATH_MAX]

)

Definition at line 931 of file utils.c.

{
    *program_name = '\0';
    return false;
}

Referenced by vkd3d_instance_init().

vkd3d_gpu_va_allocator_allocate()

D3D12_GPU_VIRTUAL_ADDRESS vkd3d_gpu_va_allocator_allocate	(	struct vkd3d_gpu_va_allocator *	allocator,
		size_t	alignment,
		uint64_t	size,
		void *	ptr
	)

Definition at line 2424 of file device.c.

{
    D3D12_GPU_VIRTUAL_ADDRESS address;
 
    if (size > ~(uint64_t)0 - (alignment - 1))
        return 0;
    size = align(size, alignment);
 
    vkd3d_mutex_lock(&allocator->mutex);
 
    if (size <= VKD3D_VA_SLAB_SIZE && allocator->free_slab)
        address = vkd3d_gpu_va_allocator_allocate_slab(allocator, size, ptr);
    else
        address = vkd3d_gpu_va_allocator_allocate_fallback(allocator, alignment, size, ptr);
 
    vkd3d_mutex_unlock(&allocator->mutex);
 
    return address;
}

Referenced by d3d12_resource_init().

vkd3d_gpu_va_allocator_dereference()

void * vkd3d_gpu_va_allocator_dereference	(	struct vkd3d_gpu_va_allocator *	allocator,
		D3D12_GPU_VIRTUAL_ADDRESS	address
	)

Definition at line 2495 of file device.c.

{
    void *ret;
 
    /* If we land in the non-fallback region, dereferencing VA is lock-less.
     * The base pointer is immutable, and the only way we can have a data race
     * is if some other thread is poking into the
     * slab_mem_allocation[base_index] block. This can only happen if someone
     * is trying to free the entry while we're dereferencing it, which would
     * be a serious application bug. */
    if (address < VKD3D_VA_FALLBACK_BASE)
        return vkd3d_gpu_va_allocator_dereference_slab(allocator, address);
 
    /* Slow fallback. */
    vkd3d_mutex_lock(&allocator->mutex);
 
    ret = vkd3d_gpu_va_allocator_dereference_fallback(allocator, address);
 
    vkd3d_mutex_unlock(&allocator->mutex);
 
    return ret;
}

Referenced by d3d12_command_list_IASetIndexBuffer(), d3d12_command_list_IASetVertexBuffers(), d3d12_command_list_set_root_cbv(), d3d12_command_list_SOSetTargets(), d3d12_command_list_WriteBufferImmediate(), d3d12_desc_create_cbv(), and vkd3d_create_raw_buffer_view().

vkd3d_gpu_va_allocator_free()

void vkd3d_gpu_va_allocator_free	(	struct vkd3d_gpu_va_allocator *	allocator,
		D3D12_GPU_VIRTUAL_ADDRESS	address
	)

Definition at line 2565 of file device.c.

{
    vkd3d_mutex_lock(&allocator->mutex);
 
    if (address < VKD3D_VA_FALLBACK_BASE)
    {
        vkd3d_gpu_va_allocator_free_slab(allocator, address);
        vkd3d_mutex_unlock(&allocator->mutex);
        return;
    }
 
    vkd3d_gpu_va_allocator_free_fallback(allocator, address);
 
    vkd3d_mutex_unlock(&allocator->mutex);
}

Referenced by d3d12_resource_destroy().

vkd3d_init_format_info()

HRESULT vkd3d_init_format_info

(

struct d3d12_device *

device

)

Definition at line 401 of file utils.c.

{
    HRESULT hr;
 
    if (FAILED(hr = vkd3d_init_depth_stencil_formats(device)))
        return hr;
 
    if (FAILED(hr = vkd3d_init_format_compatibility_lists(device)))
        vkd3d_cleanup_depth_stencil_formats(device);
 
    return hr;
}

Referenced by d3d12_device_init().

vkd3d_init_null_resources()

HRESULT vkd3d_init_null_resources	(	struct vkd3d_null_resources *	null_resources,
		struct d3d12_device *	device
	)

Definition at line 4846 of file resource.c.

{
    const bool use_sparse_resources = device->vk_info.sparse_properties.residencyNonResidentStrict;
    D3D12_HEAP_PROPERTIES heap_properties;
    D3D12_RESOURCE_DESC1 resource_desc;
    HRESULT hr;
 
    TRACE("Creating resources for NULL views.\n");
 
    memset(null_resources, 0, sizeof(*null_resources));
 
    if (device->vk_info.EXT_robustness2)
        return S_OK;
 
    memset(&heap_properties, 0, sizeof(heap_properties));
    heap_properties.Type = D3D12_HEAP_TYPE_DEFAULT;
 
    /* buffer */
    resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
    resource_desc.Alignment = 0;
    resource_desc.Width = VKD3D_NULL_BUFFER_SIZE;
    resource_desc.Height = 1;
    resource_desc.DepthOrArraySize = 1;
    resource_desc.MipLevels = 1;
    resource_desc.Format = DXGI_FORMAT_UNKNOWN;
    resource_desc.SampleDesc.Count = 1;
    resource_desc.SampleDesc.Quality = 0;
    resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
    resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
    memset(&resource_desc.SamplerFeedbackMipRegion, 0, sizeof(resource_desc.SamplerFeedbackMipRegion));
 
    if (FAILED(hr = vkd3d_create_buffer(device, &heap_properties, D3D12_HEAP_FLAG_NONE,
            &resource_desc, &null_resources->vk_buffer)))
        goto fail;
    if (FAILED(hr = vkd3d_allocate_buffer_memory(device, null_resources->vk_buffer,
            &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_buffer_memory, NULL, NULL)))
        goto fail;
 
    /* buffer UAV */
    resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 
    if (FAILED(hr = vkd3d_create_buffer(device, use_sparse_resources ? NULL : &heap_properties, D3D12_HEAP_FLAG_NONE,
            &resource_desc, &null_resources->vk_storage_buffer)))
        goto fail;
    if (!use_sparse_resources && FAILED(hr = vkd3d_allocate_buffer_memory(device, null_resources->vk_storage_buffer,
            &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_storage_buffer_memory, NULL, NULL)))
        goto fail;
 
    /* 2D SRV */
    resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    resource_desc.Alignment = 0;
    resource_desc.Width = 1;
    resource_desc.Height = 1;
    resource_desc.DepthOrArraySize = 1;
    resource_desc.MipLevels = 1;
    resource_desc.Format = VKD3D_NULL_VIEW_FORMAT;
    resource_desc.SampleDesc.Count = 1;
    resource_desc.SampleDesc.Quality = 0;
    resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
    resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
 
    if (FAILED(hr = vkd3d_create_image(device, &heap_properties, D3D12_HEAP_FLAG_NONE,
            &resource_desc, NULL, &null_resources->vk_2d_image)))
        goto fail;
    if (FAILED(hr = vkd3d_allocate_image_memory(device, null_resources->vk_2d_image,
            &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_2d_image_memory, NULL, NULL)))
        goto fail;
 
    /* 2D UAV */
    resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    resource_desc.Alignment = 0;
    resource_desc.Width = 1;
    resource_desc.Height = 1;
    resource_desc.DepthOrArraySize = 1;
    resource_desc.MipLevels = 1;
    resource_desc.Format = VKD3D_NULL_VIEW_FORMAT;
    resource_desc.SampleDesc.Count = 1;
    resource_desc.SampleDesc.Quality = 0;
    resource_desc.Layout = use_sparse_resources
            ? D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE : D3D12_TEXTURE_LAYOUT_UNKNOWN;
    resource_desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 
    if (FAILED(hr = vkd3d_create_image(device, use_sparse_resources ? NULL : &heap_properties, D3D12_HEAP_FLAG_NONE,
            &resource_desc, NULL, &null_resources->vk_2d_storage_image)))
        goto fail;
    if (!use_sparse_resources && FAILED(hr = vkd3d_allocate_image_memory(device, null_resources->vk_2d_storage_image,
            &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_2d_storage_image_memory, NULL, NULL)))
        goto fail;
 
    /* set Vulkan object names */
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_buffer,
            VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "NULL buffer");
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_buffer_memory,
            VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL memory");
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_storage_buffer,
            VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "NULL UAV buffer");
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_image,
            VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "NULL 2D SRV image");
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_image_memory,
            VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL 2D SRV memory");
    vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_storage_image,
            VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "NULL 2D UAV image");
    if (!use_sparse_resources)
    {
        vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_storage_buffer_memory,
                VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL UAV buffer memory");
        vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_storage_image_memory,
                VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL 2D UAV memory");
    }
 
    return vkd3d_init_null_resources_data(null_resources, device);
 
fail:
    ERR("Failed to initialise NULL resources, hr %s.\n", debugstr_hresult(hr));
    vkd3d_destroy_null_resources(null_resources, device);
    return hr;
}

Referenced by d3d12_device_init().

vkd3d_join_thread()

HRESULT vkd3d_join_thread	(	struct vkd3d_instance *	instance,
		union vkd3d_thread_handle *	thread
	)

Definition at line 5663 of file device.c.

{
    HRESULT hr = S_OK;
    int rc;
 
    if (instance->join_thread)
    {
        if (FAILED(hr = instance->join_thread(thread->handle)))
            ERR("Failed to join thread, hr %s.\n", debugstr_hresult(hr));
    }
    else
    {
#ifdef _WIN32
        if ((rc = WaitForSingleObject(thread->handle, INFINITE)) != WAIT_OBJECT_0)
        {
            ERR("Failed to wait for thread, ret %#x.\n", rc);
            hr = E_FAIL;
        }
        CloseHandle(thread->handle);
#else
        if ((rc = pthread_join(thread->pthread, NULL)))
        {
            ERR("Failed to join thread, error %d.\n", rc);
            hr = hresult_from_errno(rc);
        }
#endif
    }
 
    return hr;
}

Referenced by device_worker_stop(), and vkd3d_fence_worker_stop().

vkd3d_load_vk_device_procs()

HRESULT vkd3d_load_vk_device_procs	(	struct vkd3d_vk_device_procs *	procs,
		const struct vkd3d_vk_instance_procs *	parent_procs,
		VkDevice	device
	)

Definition at line 857 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
#define VK_INSTANCE_PFN   COPY_PARENT_PFN
#define VK_DEVICE_PFN     LOAD_DEVICE_PFN
#define VK_DEVICE_EXT_PFN LOAD_DEVICE_OPTIONAL_PFN
#include "vulkan_procs.h"
 
    TRACE("Loaded procs for VkDevice %p.\n", device);
    return S_OK;
}

Referenced by vkd3d_create_vk_device().

vkd3d_load_vk_global_procs()

HRESULT vkd3d_load_vk_global_procs	(	struct vkd3d_vk_global_procs *	procs,
		PFN_vkGetInstanceProcAddr	vkGetInstanceProcAddr
	)

Definition at line 811 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
    procs->vkGetInstanceProcAddr = vkGetInstanceProcAddr;
 
    LOAD_GLOBAL_PFN(vkCreateInstance)
    LOAD_GLOBAL_PFN(vkEnumerateInstanceExtensionProperties)
 
    TRACE("Loaded global Vulkan procs.\n");
    return S_OK;
}

Referenced by vkd3d_init_vk_global_procs().

vkd3d_load_vk_instance_procs()

HRESULT vkd3d_load_vk_instance_procs	(	struct vkd3d_vk_instance_procs *	procs,
		const struct vkd3d_vk_global_procs *	global_procs,
		VkInstance	instance
	)

Definition at line 834 of file utils.c.

{
    memset(procs, 0, sizeof(*procs));
 
#define VK_INSTANCE_PFN     LOAD_INSTANCE_PFN
#define VK_INSTANCE_EXT_PFN LOAD_INSTANCE_OPTIONAL_PFN
#include "vulkan_procs.h"
 
    TRACE("Loaded procs for VkInstance %p.\n", instance);
    return S_OK;
}

Referenced by vkd3d_instance_init().

vkd3d_parse_root_signature_v_1_0()

int vkd3d_parse_root_signature_v_1_0	(	const struct vkd3d_shader_code *	dxbc,
		struct vkd3d_shader_versioned_root_signature_desc *	desc
	)

Definition at line 170 of file vkd3d_main.c.

{
    struct vkd3d_shader_versioned_root_signature_desc desc, converted_desc;
    int ret;
 
    if ((ret = vkd3d_shader_parse_root_signature(dxbc, &desc, NULL)) < 0)
    {
        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
        return ret;
    }
 
    if (desc.version == VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0)
    {
        *out_desc = desc;
    }
    else
    {
        enum vkd3d_shader_root_signature_version version = desc.version;
 
        ret = vkd3d_shader_convert_root_signature(&converted_desc, VKD3D_SHADER_ROOT_SIGNATURE_VERSION_1_0, &desc);
        vkd3d_shader_free_root_signature(&desc);
        if (ret < 0)
        {
            WARN("Failed to convert from version %#x, vkd3d result %d.\n", version, ret);
            return ret;
        }
 
        *out_desc = converted_desc;
    }
 
    return ret;
}

Referenced by d3d12_root_signature_create(), and d3d12_root_signature_deserializer_init().

vkd3d_prepend_struct()

static void vkd3d_prepend_struct ( void *  header, void *  structure  )

inlinestatic

Definition at line 1781 of file vkd3d_private.h.

{
    struct
    {
        unsigned int type;
        const void *next;
    } *vkd3d_header = header, *vkd3d_structure = structure;
 
    VKD3D_ASSERT(!vkd3d_structure->next);
    vkd3d_structure->next = vkd3d_header->next;
    vkd3d_header->next = vkd3d_structure;
}

Referenced by d3d12_pipeline_state_init_compute(), and d3d12_pipeline_state_init_graphics().

vkd3d_private_data_destroy()

static void vkd3d_private_data_destroy ( struct vkd3d_private_data *  data )

inlinestatic

Definition at line 321 of file vkd3d_private.h.

{
    if (data->is_object)
        IUnknown_Release(data->u.object);
    list_remove(&data->entry);
    vkd3d_free(data);
}

Referenced by vkd3d_private_store_destroy(), and vkd3d_private_store_set_private_data().

vkd3d_private_store_destroy()

static void vkd3d_private_store_destroy ( struct vkd3d_private_store *  store )

inlinestatic

Definition at line 338 of file vkd3d_private.h.

{
    struct vkd3d_private_data *data, *cursor;
 
    LIST_FOR_EACH_ENTRY_SAFE(data, cursor, &store->content, struct vkd3d_private_data, entry)
    {
        vkd3d_private_data_destroy(data);
    }
 
    vkd3d_mutex_destroy(&store->mutex);
}

Referenced by d3d12_cache_session_destroy(), d3d12_cache_session_init(), d3d12_command_allocator_init(), d3d12_command_allocator_Release(), d3d12_command_list_init(), d3d12_command_list_Release(), d3d12_command_queue_init(), d3d12_command_queue_Release(), d3d12_command_signature_decref(), d3d12_descriptor_heap_init(), d3d12_descriptor_heap_Release(), d3d12_device_init(), d3d12_device_Release(), d3d12_fence_decref(), d3d12_heap_destroy(), d3d12_heap_init(), d3d12_pipeline_state_Release(), d3d12_query_heap_create(), d3d12_query_heap_Release(), d3d12_resource_decref(), and d3d12_root_signature_Release().

vkd3d_private_store_init()

static HRESULT vkd3d_private_store_init ( struct vkd3d_private_store *  store )

inlinestatic

Definition at line 329 of file vkd3d_private.h.

{
    list_init(&store->content);
 
    vkd3d_mutex_init(&store->mutex);
 
    return S_OK;
}

Referenced by d3d12_cache_session_init(), d3d12_command_allocator_init(), d3d12_command_list_init(), d3d12_command_queue_init(), d3d12_command_signature_create(), d3d12_descriptor_heap_init(), d3d12_device_init(), d3d12_fence_init(), d3d12_heap_init(), d3d12_pipeline_state_init_compute(), d3d12_pipeline_state_init_graphics(), d3d12_query_heap_create(), d3d12_resource_init(), d3d12_root_signature_init(), and vkd3d_create_image_resource().

vkd3d_queue_acquire()

VkQueue vkd3d_queue_acquire

(

struct vkd3d_queue *

queue

)

Definition at line 91 of file command.c.

{
    TRACE("queue %p.\n", queue);
 
    vkd3d_mutex_lock(&queue->mutex);
 
    VKD3D_ASSERT(queue->vk_queue);
    return queue->vk_queue;
}

Referenced by d3d12_command_queue_execute(), d3d12_command_queue_SetName(), d3d12_command_queue_signal(), d3d12_command_queue_wait_binary_semaphore_locked(), d3d12_command_queue_wait_locked(), vkd3d_acquire_vk_queue(), vkd3d_init_null_resources_data(), and vkd3d_queue_wait_idle().

vkd3d_queue_create()

HRESULT vkd3d_queue_create	(	struct d3d12_device *	device,
		uint32_t	family_index,
		const VkQueueFamilyProperties *	properties,
		struct vkd3d_queue **	queue
	)

Definition at line 34 of file command.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    struct vkd3d_queue *object;
 
    if (!(object = vkd3d_malloc(sizeof(*object))))
        return E_OUTOFMEMORY;
 
    vkd3d_mutex_init(&object->mutex);
 
    object->completed_sequence_number = 0;
    object->submitted_sequence_number = 0;
 
    object->vk_family_index = family_index;
    object->vk_queue_flags = properties->queueFlags;
    object->timestamp_bits = properties->timestampValidBits;
 
    object->semaphores = NULL;
    object->semaphores_size = 0;
    object->semaphore_count = 0;
 
    memset(object->old_vk_semaphores, 0, sizeof(object->old_vk_semaphores));
 
    VK_CALL(vkGetDeviceQueue(device->vk_device, family_index, 0, &object->vk_queue));
 
    TRACE("Created queue %p for queue family index %u.\n", object, family_index);
 
    *queue = object;
 
    return S_OK;
}

Referenced by d3d12_device_create_vkd3d_queues().

vkd3d_queue_destroy()

void vkd3d_queue_destroy	(	struct vkd3d_queue *	queue,
		struct d3d12_device *	device
	)

Definition at line 67 of file command.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    unsigned int i;
 
    vkd3d_mutex_lock(&queue->mutex);
 
    for (i = 0; i < queue->semaphore_count; ++i)
        VK_CALL(vkDestroySemaphore(device->vk_device, queue->semaphores[i].vk_semaphore, NULL));
 
    vkd3d_free(queue->semaphores);
 
    for (i = 0; i < ARRAY_SIZE(queue->old_vk_semaphores); ++i)
    {
        if (queue->old_vk_semaphores[i])
            VK_CALL(vkDestroySemaphore(device->vk_device, queue->old_vk_semaphores[i], NULL));
    }
 
    vkd3d_mutex_unlock(&queue->mutex);
 
    vkd3d_mutex_destroy(&queue->mutex);
    vkd3d_free(queue);
}

Referenced by d3d12_device_destroy_vkd3d_queues().

vkd3d_queue_release()

void vkd3d_queue_release

(

struct vkd3d_queue *

queue

)

Definition at line 101 of file command.c.

{
    TRACE("queue %p.\n", queue);
 
    vkd3d_mutex_unlock(&queue->mutex);
}

Referenced by d3d12_command_queue_execute(), d3d12_command_queue_SetName(), d3d12_command_queue_signal(), d3d12_command_queue_wait_binary_semaphore_locked(), d3d12_command_queue_wait_locked(), vkd3d_init_null_resources_data(), vkd3d_queue_wait_idle(), and vkd3d_release_vk_queue().

vkd3d_render_pass_cache_cleanup()

void vkd3d_render_pass_cache_cleanup	(	struct vkd3d_render_pass_cache *	cache,
		struct d3d12_device *	device
	)

Definition at line 1845 of file state.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    unsigned int i;
 
    for (i = 0; i < cache->render_pass_count; ++i)
    {
        struct vkd3d_render_pass_entry *current = &cache->render_passes[i];
        VK_CALL(vkDestroyRenderPass(device->vk_device, current->vk_render_pass, NULL));
    }
 
    vkd3d_free(cache->render_passes);
    cache->render_passes = NULL;
}

Referenced by d3d12_device_Release().

vkd3d_render_pass_cache_find()

HRESULT vkd3d_render_pass_cache_find	(	struct vkd3d_render_pass_cache *	cache,
		struct d3d12_device *	device,
		const struct vkd3d_render_pass_key *	key,
		VkRenderPass *	vk_render_pass
	)

Definition at line 1809 of file state.c.

{
    bool found = false;
    HRESULT hr = S_OK;
    unsigned int i;
 
    vkd3d_mutex_lock(&device->pipeline_cache_mutex);
 
    for (i = 0; i < cache->render_pass_count; ++i)
    {
        struct vkd3d_render_pass_entry *current = &cache->render_passes[i];
 
        if (!memcmp(&current->key, key, sizeof(*key)))
        {
            *vk_render_pass = current->vk_render_pass;
            found = true;
            break;
        }
    }
 
    if (!found)
        hr = vkd3d_render_pass_cache_create_pass_locked(cache, device, key, vk_render_pass);
 
    vkd3d_mutex_unlock(&device->pipeline_cache_mutex);
 
    return hr;
}

Referenced by d3d12_graphics_pipeline_state_create_render_pass().

vkd3d_render_pass_cache_init()

void vkd3d_render_pass_cache_init

(

struct vkd3d_render_pass_cache *

cache

)

Definition at line 1838 of file state.c.

{
    cache->render_passes = NULL;
    cache->render_pass_count = 0;
    cache->render_passes_size = 0;
}

Referenced by d3d12_device_init().

vkd3d_set_private_data()

HRESULT vkd3d_set_private_data	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		unsigned int	data_size,
		const void *	data
	)

Definition at line 1033 of file utils.c.

{
    HRESULT hr;
 
    vkd3d_mutex_lock(&store->mutex);
 
    hr = vkd3d_private_store_set_private_data(store, tag, data, data_size, false);
 
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_SetPrivateData(), d3d12_command_allocator_SetPrivateData(), d3d12_command_list_SetPrivateData(), d3d12_command_queue_SetPrivateData(), d3d12_command_signature_SetPrivateData(), d3d12_descriptor_heap_SetPrivateData(), d3d12_device_SetPrivateData(), d3d12_fence_SetPrivateData(), d3d12_heap_SetPrivateData(), d3d12_pipeline_state_SetPrivateData(), d3d12_query_heap_SetPrivateData(), d3d12_resource_SetPrivateData(), and d3d12_root_signature_SetPrivateData().

vkd3d_set_private_data_interface()

HRESULT vkd3d_set_private_data_interface	(	struct vkd3d_private_store *	store,
		const GUID *	tag,
		const IUnknown *	object
	)

Definition at line 1046 of file utils.c.

{
    const void *data = object ? object : (void *)&object;
    HRESULT hr;
 
    vkd3d_mutex_lock(&store->mutex);
 
    hr = vkd3d_private_store_set_private_data(store, tag, data, sizeof(object), !!object);
 
    vkd3d_mutex_unlock(&store->mutex);
    return hr;
}

Referenced by d3d12_cache_session_SetPrivateDataInterface(), d3d12_command_allocator_SetPrivateDataInterface(), d3d12_command_list_SetPrivateDataInterface(), d3d12_command_queue_SetPrivateDataInterface(), d3d12_command_signature_SetPrivateDataInterface(), d3d12_descriptor_heap_SetPrivateDataInterface(), d3d12_device_SetPrivateDataInterface(), d3d12_fence_SetPrivateDataInterface(), d3d12_heap_SetPrivateDataInterface(), d3d12_pipeline_state_SetPrivateDataInterface(), d3d12_query_heap_SetPrivateDataInterface(), d3d12_resource_SetPrivateDataInterface(), and d3d12_root_signature_SetPrivateDataInterface().

vkd3d_set_vk_object_name()

HRESULT vkd3d_set_vk_object_name	(	struct d3d12_device *	device,
		uint64_t	vk_object,
		VkDebugReportObjectTypeEXT	vk_object_type,
		const WCHAR *	name
	)

Definition at line 1077 of file utils.c.

{
    char *name_utf8;
    VkResult vr;
 
    if (!name)
        return E_INVALIDARG;
 
    if (!device->vk_info.EXT_debug_marker)
        return S_OK;
 
    if (!(name_utf8 = vkd3d_strdup_w_utf8(name, device->wchar_size)))
        return E_OUTOFMEMORY;
 
    vr = vkd3d_set_vk_object_name_utf8(device, vk_object, vk_object_type, name_utf8);
 
    vkd3d_free(name_utf8);
 
    return hresult_from_vk_result(vr);
}

Referenced by d3d12_command_allocator_SetName(), d3d12_command_queue_SetName(), d3d12_device_SetName(), d3d12_heap_SetName(), d3d12_pipeline_state_SetName(), d3d12_query_heap_SetName(), and d3d12_resource_SetName().

vkd3d_set_vk_object_name_utf8()

VkResult vkd3d_set_vk_object_name_utf8	(	struct d3d12_device *	device,
		uint64_t	vk_object,
		VkDebugReportObjectTypeEXT	vk_object_type,
		const char *	name
	)

Definition at line 1060 of file utils.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
    VkDebugMarkerObjectNameInfoEXT info;
 
    if (!device->vk_info.EXT_debug_marker)
        return VK_SUCCESS;
 
    info.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
    info.pNext = NULL;
    info.objectType = vk_object_type;
    info.object = vk_object;
    info.pObjectName = name;
    return VK_CALL(vkDebugMarkerSetObjectNameEXT(device->vk_device, &info));
}

Referenced by vkd3d_init_null_resources(), and vkd3d_set_vk_object_name().

vkd3d_shader_cache_decref()

unsigned int vkd3d_shader_cache_decref

(

struct vkd3d_shader_cache *

cache

)

Definition at line 115 of file cache.c.

{
    unsigned int refcount = vkd3d_atomic_decrement_u32(&cache->refcount);
    TRACE("cache %p refcount %u.\n", cache, refcount);
 
    if (refcount)
        return refcount;
 
    rb_destroy(&cache->tree, vkd3d_shader_cache_destroy_entry, NULL);
    vkd3d_mutex_destroy(&cache->lock);
 
    vkd3d_free(cache);
    return 0;
}

Referenced by d3d12_cache_session_destroy().

vkd3d_shader_cache_get()

int vkd3d_shader_cache_get	(	struct vkd3d_shader_cache *	cache,
		const void *	key,
		size_t	key_size,
		void *	value,
		size_t *	value_size
	)

Definition at line 208 of file cache.c.

{
    struct shader_cache_entry *e;
    struct shader_cache_key k;
    struct rb_entry *entry;
    enum vkd3d_result ret;
    size_t size_in;
 
    TRACE("%p, %p, %#zx, %p, %p.\n", cache, key, key_size, value, value_size);
 
    size_in = *value_size;
 
    k.hash = vkd3d_shader_cache_hash_key(key, key_size);
    k.key = key;
    k.key_size = key_size;
 
    vkd3d_shader_cache_lock(cache);
 
    entry = rb_get(&cache->tree, &k);
    if (!entry)
    {
        WARN("Entry not found.\n");
        ret = VKD3D_ERROR_NOT_FOUND;
        goto done;
    }
 
    e = RB_ENTRY_VALUE(entry, struct shader_cache_entry, entry);
 
    *value_size = e->h.value_size;
    if (!value)
    {
        TRACE("Found item %#"PRIx64", returning needed size %#"PRIx64".\n",
                e->h.hash, e->h.value_size);
        ret = VKD3D_OK;
        goto done;
    }
 
    if (size_in < e->h.value_size)
    {
        WARN("Output buffer is too small for item %#"PRIx64", got %#zx want %#"PRIx64".\n",
                e->h.hash, size_in, e->h.value_size);
        ret = VKD3D_ERROR_MORE_DATA;
        goto done;
    }
 
    memcpy(value, e->payload + e->h.key_size, e->h.value_size);
    ret = VKD3D_OK;
    TRACE("Returning cached item %#"PRIx64".\n", e->h.hash);
 
done:
    vkd3d_shader_cache_unlock(cache);
    return ret;
}

Referenced by d3d12_cache_session_FindValue().

vkd3d_shader_cache_incref()

unsigned int vkd3d_shader_cache_incref

(

struct vkd3d_shader_cache *

cache

)

Definition at line 101 of file cache.c.

{
    unsigned int refcount = vkd3d_atomic_increment_u32(&cache->refcount);
    TRACE("cache %p refcount %u.\n", cache, refcount);
    return refcount;
}

Referenced by d3d12_cache_session_init().

vkd3d_shader_cache_put()

int vkd3d_shader_cache_put	(	struct vkd3d_shader_cache *	cache,
		const void *	key,
		size_t	key_size,
		const void *	value,
		size_t	value_size
	)

Definition at line 153 of file cache.c.

{
    struct shader_cache_entry *e;
    struct shader_cache_key k;
    struct rb_entry *entry;
    enum vkd3d_result ret;
 
    TRACE("%p, %p, %#zx, %p, %#zx.\n", cache, key, key_size, value, value_size);
 
    k.hash = vkd3d_shader_cache_hash_key(key, key_size);
    k.key = key;
    k.key_size = key_size;
 
    vkd3d_shader_cache_lock(cache);
 
    entry = rb_get(&cache->tree, &k);
    e = entry ? RB_ENTRY_VALUE(entry, struct shader_cache_entry, entry) : NULL;
 
    if (e)
    {
        WARN("Key already exists, returning VKD3D_ERROR_KEY_ALREADY_EXISTS.\n");
        ret = VKD3D_ERROR_KEY_ALREADY_EXISTS;
        goto done;
    }
 
    e = vkd3d_malloc(sizeof(*e));
    if (!e)
    {
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
        goto done;
    }
    e->payload = vkd3d_malloc(key_size + value_size);
    if (!e->payload)
    {
        vkd3d_free(e);
        ret = VKD3D_ERROR_OUT_OF_MEMORY;
        goto done;
    }
 
    e->h.key_size = key_size;
    e->h.value_size = value_size;
    e->h.hash = k.hash;
    memcpy(e->payload, key, key_size);
    memcpy(e->payload + key_size, value, value_size);
 
    vkd3d_shader_cache_add_entry(cache, e);
    TRACE("Cache entry %#"PRIx64" stored.\n", k.hash);
    ret = VKD3D_OK;
 
done:
    vkd3d_shader_cache_unlock(cache);
    return ret;
}

Referenced by d3d12_cache_session_StoreValue().

vkd3d_shader_open_cache()

int vkd3d_shader_open_cache

(

struct vkd3d_shader_cache **

cache

)

Definition at line 82 of file cache.c.

{
    struct vkd3d_shader_cache *object;
 
    TRACE("%p.\n", cache);
 
    object = vkd3d_malloc(sizeof(*object));
    if (!object)
        return VKD3D_ERROR_OUT_OF_MEMORY;
 
    object->refcount = 1;
    rb_init(&object->tree, vkd3d_shader_cache_compare_key);
    vkd3d_mutex_init(&object->lock);
 
    *cache = object;
 
    return VKD3D_OK;
}

Referenced by d3d12_cache_session_init().

vkd3d_uav_clear_state_cleanup()

void vkd3d_uav_clear_state_cleanup	(	struct vkd3d_uav_clear_state *	state,
		struct d3d12_device *	device
	)

Definition at line 4054 of file state.c.

{
    const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
 
    vkd3d_uav_clear_pipelines_cleanup(&state->pipelines_uint, device);
    vkd3d_uav_clear_pipelines_cleanup(&state->pipelines_float, device);
 
    VK_CALL(vkDestroyPipelineLayout(device->vk_device, state->vk_pipeline_layout_image, NULL));
    VK_CALL(vkDestroyPipelineLayout(device->vk_device, state->vk_pipeline_layout_buffer, NULL));
 
    VK_CALL(vkDestroyDescriptorSetLayout(device->vk_device, state->vk_set_layout_image, NULL));
    VK_CALL(vkDestroyDescriptorSetLayout(device->vk_device, state->vk_set_layout_buffer, NULL));
}

Referenced by d3d12_device_init(), d3d12_device_Release(), and vkd3d_uav_clear_state_init().

vkd3d_uav_clear_state_init()

HRESULT vkd3d_uav_clear_state_init	(	struct vkd3d_uav_clear_state *	state,
		struct d3d12_device *	device
	)

Definition at line 4068 of file state.c.

{
    struct vkd3d_shader_push_constant_buffer push_constant;
    struct vkd3d_shader_interface_info shader_interface;
    struct vkd3d_shader_resource_binding binding;
    VkDescriptorSetLayoutBinding set_binding;
    VkPushConstantRange push_constant_range;
    unsigned int i;
    HRESULT hr;
 
    const struct
    {
        VkDescriptorSetLayout *set_layout;
        VkPipelineLayout *pipeline_layout;
        VkDescriptorType descriptor_type;
    }
    set_layouts[] =
    {
        {&state->vk_set_layout_buffer, &state->vk_pipeline_layout_buffer, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER},
        {&state->vk_set_layout_image,  &state->vk_pipeline_layout_image, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE},
    };
 
    const struct
    {
        VkPipeline *pipeline;
        VkPipelineLayout *pipeline_layout;
        struct vkd3d_shader_code code;
    }
    pipelines[] =
    {
#define SHADER_CODE(name) {name, sizeof(name)}
        {&state->pipelines_float.buffer, &state->vk_pipeline_layout_buffer,
                SHADER_CODE(cs_uav_clear_buffer_float_code)},
        {&state->pipelines_float.image_1d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_1d_float_code)},
        {&state->pipelines_float.image_1d_array, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_1d_array_float_code)},
        {&state->pipelines_float.image_2d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_2d_float_code)},
        {&state->pipelines_float.image_2d_array, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_2d_array_float_code)},
        {&state->pipelines_float.image_3d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_3d_float_code)},
 
        {&state->pipelines_uint.buffer, &state->vk_pipeline_layout_buffer,
                SHADER_CODE(cs_uav_clear_buffer_uint_code)},
        {&state->pipelines_uint.image_1d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_1d_uint_code)},
        {&state->pipelines_uint.image_1d_array, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_1d_array_uint_code)},
        {&state->pipelines_uint.image_2d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_2d_uint_code)},
        {&state->pipelines_uint.image_2d_array, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_2d_array_uint_code)},
        {&state->pipelines_uint.image_3d, &state->vk_pipeline_layout_image,
                SHADER_CODE(cs_uav_clear_3d_uint_code)},
#undef SHADER_CODE
    };
 
    memset(state, 0, sizeof(*state));
 
    set_binding.binding = 0;
    set_binding.descriptorCount = 1;
    set_binding.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
    set_binding.pImmutableSamplers = NULL;
 
    binding.type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV;
    binding.register_space = 0;
    binding.register_index = 0;
    binding.shader_visibility = VKD3D_SHADER_VISIBILITY_COMPUTE;
    binding.binding.set = 0;
    binding.binding.binding = 0;
    binding.binding.count = 1;
 
    push_constant_range.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
    push_constant_range.offset = 0;
    push_constant_range.size = sizeof(struct vkd3d_uav_clear_args);
 
    push_constant.register_space = 0;
    push_constant.register_index = 0;
    push_constant.shader_visibility = VKD3D_SHADER_VISIBILITY_COMPUTE;
    push_constant.offset = 0;
    push_constant.size = sizeof(struct vkd3d_uav_clear_args);
 
    for (i = 0; i < ARRAY_SIZE(set_layouts); ++i)
    {
        set_binding.descriptorType = set_layouts[i].descriptor_type;
 
        if (FAILED(hr = vkd3d_create_descriptor_set_layout(device, 0,
                1, false, &set_binding, set_layouts[i].set_layout)))
        {
            ERR("Failed to create descriptor set layout %u, hr %s.\n", i, debugstr_hresult(hr));
            goto fail;
        }
 
        if (FAILED(hr = vkd3d_create_pipeline_layout(device, 1, set_layouts[i].set_layout,
                1, &push_constant_range, set_layouts[i].pipeline_layout)))
        {
            ERR("Failed to create pipeline layout %u, hr %s.\n", i, debugstr_hresult(hr));
            goto fail;
        }
    }
 
    shader_interface.type = VKD3D_SHADER_STRUCTURE_TYPE_INTERFACE_INFO;
    shader_interface.next = NULL;
    shader_interface.bindings = &binding;
    shader_interface.binding_count = 1;
    shader_interface.push_constant_buffers = &push_constant;
    shader_interface.push_constant_buffer_count = 1;
    shader_interface.combined_samplers = NULL;
    shader_interface.combined_sampler_count = 0;
    shader_interface.uav_counters = NULL;
    shader_interface.uav_counter_count = 0;
 
    for (i = 0; i < ARRAY_SIZE(pipelines); ++i)
    {
        struct vkd3d_shader_code dxbc;
        int ret;
 
        if ((ret = compile_hlsl_cs(&pipelines[i].code, &dxbc)))
        {
            ERR("Failed to compile HLSL compute shader %u, ret %d.\n", i, ret);
            hr = hresult_from_vk_result(ret);
            goto fail;
        }
 
        if (pipelines[i].pipeline_layout == &state->vk_pipeline_layout_buffer)
            binding.flags = VKD3D_SHADER_BINDING_FLAG_BUFFER;
        else
            binding.flags = VKD3D_SHADER_BINDING_FLAG_IMAGE;
 
        hr = vkd3d_create_compute_pipeline(device, &(D3D12_SHADER_BYTECODE){dxbc.code, dxbc.size},
                &shader_interface, *pipelines[i].pipeline_layout, pipelines[i].pipeline);
        vkd3d_shader_free_shader_code(&dxbc);
        if (FAILED(hr))
        {
            ERR("Failed to create compute pipeline %u, hr %s.\n", i, debugstr_hresult(hr));
            goto fail;
        }
    }
 
    return S_OK;
 
fail:
    vkd3d_uav_clear_state_cleanup(state, device);
    return hr;
}

Referenced by d3d12_device_init().

vkd3d_view_decref()

void vkd3d_view_decref	(	void *	view,
		struct d3d12_device *	device
	)

Definition at line 2453 of file resource.c.

{
    union d3d12_desc_object u = {view};
 
    if (vkd3d_atomic_decrement_u32(&u.header->refcount))
        return;
 
    if (u.header->magic != VKD3D_DESCRIPTOR_MAGIC_CBV)
        vkd3d_view_destroy(u.view, device);
    else
        vkd3d_desc_object_cache_push(&device->cbuffer_desc_cache, u.object);
}

Referenced by d3d12_command_allocator_free_resources(), d3d12_command_list_ClearUnorderedAccessViewFloat(), d3d12_command_list_ClearUnorderedAccessViewUint(), d3d12_desc_create_sampler(), d3d12_desc_get_object_ref(), d3d12_desc_replace(), d3d12_dsv_desc_destroy(), d3d12_rtv_desc_destroy(), descriptor_writes_free_object_refs(), and vkd3d_create_buffer_uav().

vkd3d_view_incref()

static bool vkd3d_view_incref ( void *  desc )

inlinestatic

Definition at line 660 of file vkd3d_private.h.

{
    struct vkd3d_desc_header *h = desc;
    unsigned int refcount;
 
    do
    {
        refcount = h->refcount;
        /* Avoid incrementing a freed object. Reading the value is safe because objects are recycled. */
        if (refcount <= 0)
            return false;
    }
    while (!vkd3d_atomic_compare_exchange_u32(&h->refcount, refcount, refcount + 1));
 
    return true;
}

Referenced by d3d12_command_allocator_add_view(), and d3d12_desc_get_object_ref().

vkd3d_vk_descriptor_set_index_from_vk_descriptor_type()

static enum vkd3d_vk_descriptor_set_index vkd3d_vk_descriptor_set_index_from_vk_descriptor_type ( VkDescriptorType  type )

inlinestatic

Definition at line 794 of file vkd3d_private.h.

{
    VKD3D_ASSERT(type <= VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
    VKD3D_ASSERT(vk_descriptor_set_index_table[type] < VKD3D_SET_INDEX_COUNT);
 
    return vk_descriptor_set_index_table[type];
}

Referenced by d3d12_desc_write_vk_heap().

Variable Documentation

object_global_serial_id

uint64_t object_global_serial_id

extern

Definition at line 25 of file resource.c.

Referenced by d3d12_descriptor_heap_init().

vk_descriptor_set_index_table

enum vkd3d_vk_descriptor_set_index vk_descriptor_set_index_table[]

extern

Definition at line 4227 of file resource.c.

Referenced by vkd3d_vk_descriptor_set_index_from_vk_descriptor_type().

vkd3d_build

const char vkd3d_build[]

extern