wined3d_vk.h File Reference

#include "stdint.h"
#include "wine/list.h"
#include "wine/wined3d.h"
#include "wine/vulkan.h"
#include "wined3d_private.h"

Include dependency graph for wined3d_vk.h:

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

Go to the source code of this file.

Classes
struct	vulkan_ops
struct	wined3d_vk_info
struct	wined3d_bo_vk
struct	wined3d_bo_slab_vk_key
struct	wined3d_bo_slab_vk
struct	wined3d_image_vk
struct	wined3d_query_pool_vk
struct	wined3d_query_pool_idx_vk
struct	wined3d_query_vk
struct	wined3d_command_buffer_vk
struct	wined3d_retired_object_vk
struct	wined3d_retired_objects_vk
struct	wined3d_render_pass_attachment_vk
struct	wined3d_render_pass_key_vk
struct	wined3d_render_pass_vk
struct	wined3d_pipeline_layout_key_vk
struct	wined3d_pipeline_layout_vk
struct	wined3d_graphics_pipeline_key_vk
struct	wined3d_graphics_pipeline_vk
struct	wined3d_shader_resource_binding
struct	wined3d_shader_resource_bindings
struct	wined3d_shader_descriptor_writes_vk
struct	wined3d_context_vk
struct	wined3d_adapter_vk
struct	wined3d_null_resources_vk
struct	wined3d_null_views_vk
struct	wined3d_allocator_chunk_vk
struct	wined3d_uav_clear_pipelines_vk
struct	wined3d_uav_clear_state_vk
struct	wined3d_device_vk
struct	wined3d_texture_vk
struct	wined3d_sampler_vk
struct	wined3d_buffer_vk
struct	wined3d_rendertarget_view_vk
struct	wined3d_view_vk
struct	wined3d_shader_resource_view_vk
struct	wined3d_unordered_access_view_vk
struct	wined3d_swapchain_vk
struct	wined3d_format_vk

Macros
#define	VK_NO_PROTOTYPES
#define	VK_INSTANCE_FUNCS()
#define	VK_DEVICE_FUNCS()
#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_DEVICE_PFN   DECLARE_VK_PFN
#define	VK_DEVICE_EXT_PFN   DECLARE_VK_PFN
#define	VK_CALL(f)   (vk_info->vk_ops.f)
#define	WINED3D_QUERY_VK_FLAG_ACTIVE   0x00000001
#define	WINED3D_QUERY_VK_FLAG_STARTED   0x00000002
#define	WINED3D_QUERY_VK_FLAG_RENDER_PASS   0x00000004
#define	WINED3D_FB_ATTACHMENT_FLAG_DISCARDED   1
#define	WINED3D_FB_ATTACHMENT_FLAG_CLEAR_C   2
#define	WINED3D_FB_ATTACHMENT_FLAG_CLEAR_S   4
#define	WINED3D_FB_ATTACHMENT_FLAG_CLEAR_Z   8

Enumerations
enum	wined3d_vk_extension {   WINED3D_VK_EXT_NONE , WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE , WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2 , WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3 ,   WINED3D_VK_EXT_HOST_QUERY_RESET , WINED3D_VK_EXT_SHADER_STENCIL_EXPORT , WINED3D_VK_EXT_TRANSFORM_FEEDBACK , WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR ,   WINED3D_VK_KHR_MAINTENANCE2 , WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE , WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS , WINED3D_VK_EXT_COUNT }
enum	wined3d_retired_object_type_vk {   WINED3D_RETIRED_FREE_VK , WINED3D_RETIRED_FRAMEBUFFER_VK , WINED3D_RETIRED_DESCRIPTOR_POOL_VK , WINED3D_RETIRED_MEMORY_VK ,   WINED3D_RETIRED_ALLOCATOR_BLOCK_VK , WINED3D_RETIRED_BO_SLAB_SLICE_VK , WINED3D_RETIRED_BUFFER_VK , WINED3D_RETIRED_IMAGE_VK ,   WINED3D_RETIRED_BUFFER_VIEW_VK , WINED3D_RETIRED_IMAGE_VIEW_VK , WINED3D_RETIRED_SAMPLER_VK , WINED3D_RETIRED_QUERY_POOL_VK ,   WINED3D_RETIRED_EVENT_VK , WINED3D_RETIRED_PIPELINE_VK }
enum	wined3d_shader_descriptor_type {   WINED3D_SHADER_DESCRIPTOR_TYPE_CBV , WINED3D_SHADER_DESCRIPTOR_TYPE_SRV , WINED3D_SHADER_DESCRIPTOR_TYPE_UAV , WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER ,   WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER }

Functions
VkAccessFlags	vk_access_mask_from_bind_flags (uint32_t bind_flags)
VkCompareOp	vk_compare_op_from_wined3d (enum wined3d_cmp_func op)
VkImageViewType	vk_image_view_type_from_wined3d (enum wined3d_resource_type type, uint32_t flags)
VkPipelineStageFlags	vk_pipeline_stage_mask_from_bind_flags (uint32_t bind_flags)
VkShaderStageFlagBits	vk_shader_stage_from_wined3d (enum wined3d_shader_type shader_type)
VkAccessFlags	vk_access_mask_from_buffer_usage (VkBufferUsageFlags usage)
VkPipelineStageFlags	vk_pipeline_stage_mask_from_buffer_usage (VkBufferUsageFlags usage)
VkBufferUsageFlags	vk_buffer_usage_from_bind_flags (uint32_t bind_flags)
VkMemoryPropertyFlags	vk_memory_type_from_access_flags (uint32_t access, uint32_t usage)
void	wined3d_format_colour_to_vk (const struct wined3d_format *format, const struct wined3d_color *c, VkClearColorValue *retval)
void	wined3d_vk_swizzle_from_color_fixup (VkComponentMapping *mapping, struct color_fixup_desc fixup)
const char *	wined3d_debug_vkresult (VkResult vr)
static VkImageAspectFlags	vk_aspect_mask_from_format (const struct wined3d_format *format)
static struct wined3d_bo_vk *	wined3d_bo_vk (struct wined3d_bo *bo)
void *	wined3d_bo_slab_vk_map (struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
void	wined3d_bo_slab_vk_unmap (struct wined3d_bo_slab_vk *slab_vk, struct wined3d_context_vk *context_vk)
bool	wined3d_query_pool_vk_allocate_query (struct wined3d_query_pool_vk *pool_vk, size_t *idx)
void	wined3d_query_pool_vk_mark_free (struct wined3d_context_vk *context_vk, struct wined3d_query_pool_vk *pool_vk, uint32_t start, uint32_t count)
void	wined3d_query_pool_vk_cleanup (struct wined3d_query_pool_vk *pool_vk, struct wined3d_context_vk *context_vk)
bool	wined3d_query_pool_vk_init (struct wined3d_query_pool_vk *pool_vk, struct wined3d_context_vk *context_vk, enum wined3d_query_type type, struct list *free_pools)
static struct wined3d_query_vk *	wined3d_query_vk (struct wined3d_query *query)
bool	wined3d_query_vk_accumulate_data (struct wined3d_query_vk *query_vk, struct wined3d_device_vk *device_vk, const struct wined3d_query_pool_idx_vk *pool_idx)
HRESULT	wined3d_query_vk_create (struct wined3d_device *device, enum wined3d_query_type type, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
void	wined3d_query_vk_resume (struct wined3d_query_vk *query_vk, struct wined3d_context_vk *context_vk)
void	wined3d_query_vk_suspend (struct wined3d_query_vk *query_vk, struct wined3d_context_vk *context_vk)
static struct wined3d_context_vk *	wined3d_context_vk (struct wined3d_context *context)
bool	wined3d_context_vk_allocate_query (struct wined3d_context_vk *context_vk, enum wined3d_query_type type, struct wined3d_query_pool_idx_vk *pool_idx)
VkDeviceMemory	wined3d_context_vk_allocate_vram_chunk_memory (struct wined3d_context_vk *context_vk, unsigned int pool, size_t size)
VkCommandBuffer	wined3d_context_vk_apply_compute_state (struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk)
VkCommandBuffer	wined3d_context_vk_apply_draw_state (struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk, bool indexed)
void	wined3d_context_vk_cleanup (struct wined3d_context_vk *context_vk)
BOOL	wined3d_context_vk_create_bo (struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo)
BOOL	wined3d_context_vk_create_image (struct wined3d_context_vk *context_vk, VkImageType vk_image_type, VkImageUsageFlags usage, VkFormat vk_format, unsigned int width, unsigned int height, unsigned int depth, unsigned int sample_count, unsigned int mip_levels, unsigned int layer_count, unsigned int flags, struct wined3d_image_vk *image)
void	wined3d_context_vk_destroy_allocator_block (struct wined3d_context_vk *context_vk, struct wined3d_allocator_block *block, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_bo (struct wined3d_context_vk *context_vk, const struct wined3d_bo_vk *bo)
void	wined3d_context_vk_destroy_image (struct wined3d_context_vk *context_vk, struct wined3d_image_vk *image_vk)
void	wined3d_context_vk_destroy_vk_buffer_view (struct wined3d_context_vk *context_vk, VkBufferView vk_view, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_framebuffer (struct wined3d_context_vk *context_vk, VkFramebuffer vk_framebuffer, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_image (struct wined3d_context_vk *context_vk, VkImage vk_image, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_image_view (struct wined3d_context_vk *context_vk, VkImageView vk_view, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_memory (struct wined3d_context_vk *context_vk, VkDeviceMemory vk_memory, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_sampler (struct wined3d_context_vk *context_vk, VkSampler vk_sampler, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_event (struct wined3d_context_vk *context_vk, VkEvent vk_event, uint64_t command_buffer_id)
void	wined3d_context_vk_destroy_vk_pipeline (struct wined3d_context_vk *context_vk, VkPipeline vk_pipeline, uint64_t command_buffer_id)
void	wined3d_context_vk_end_current_render_pass (struct wined3d_context_vk *context_vk)
VkCommandBuffer	wined3d_context_vk_get_command_buffer (struct wined3d_context_vk *context_vk)
struct wined3d_pipeline_layout_vk *	wined3d_context_vk_get_pipeline_layout (struct wined3d_context_vk *context_vk, VkDescriptorSetLayoutBinding *bindings, SIZE_T binding_count)
VkRenderPass	wined3d_context_vk_get_render_pass (struct wined3d_context_vk *context_vk, const struct wined3d_fb_state *fb, unsigned int rt_count, bool depth_stencil, uint32_t clear_flags)
void	wined3d_context_vk_image_barrier (struct wined3d_context_vk *context_vk, VkCommandBuffer vk_command_buffer, VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask, VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask, VkImageLayout old_layout, VkImageLayout new_layout, VkImage image, const VkImageSubresourceRange *range)
HRESULT	wined3d_context_vk_init (struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain)
void	wined3d_context_vk_submit_command_buffer (struct wined3d_context_vk *context_vk, unsigned int wait_semaphore_count, const VkSemaphore *wait_semaphores, const VkPipelineStageFlags *wait_stages, unsigned int signal_semaphore_count, const VkSemaphore *signal_semaphores)
void	wined3d_context_vk_wait_command_buffer (struct wined3d_context_vk *context_vk, uint64_t id)
VkDescriptorSet	wined3d_context_vk_create_vk_descriptor_set (struct wined3d_context_vk *context_vk, VkDescriptorSetLayout vk_set_layout)
static struct wined3d_adapter_vk *	wined3d_adapter_vk (struct wined3d_adapter *adapter)
void	adapter_vk_copy_bo_address (struct wined3d_context *context, const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src, unsigned int range_count, const struct wined3d_range *ranges, uint32_t map_flags)
unsigned int	wined3d_adapter_vk_get_memory_type_index (const struct wined3d_adapter_vk *adapter_vk, uint32_t memory_type_mask, VkMemoryPropertyFlags flags)
BOOL	wined3d_adapter_vk_init_format_info (struct wined3d_adapter_vk *adapter_vk, const struct wined3d_vk_info *vk_info)
static struct wined3d_allocator_chunk_vk *	wined3d_allocator_chunk_vk (struct wined3d_allocator_chunk *chunk)
void *	wined3d_allocator_chunk_vk_map (struct wined3d_allocator_chunk_vk *chunk_vk, struct wined3d_context_vk *context_vk)
void	wined3d_allocator_chunk_vk_unmap (struct wined3d_allocator_chunk_vk *chunk_vk, struct wined3d_context_vk *context_vk)
static struct wined3d_device_vk *	wined3d_device_vk (struct wined3d_device *device)
static struct wined3d_device_vk *	wined3d_device_vk_from_allocator (struct wined3d_allocator *allocator)
static void	wined3d_device_vk_allocator_lock (struct wined3d_device_vk *device_vk)
static void	wined3d_device_vk_allocator_unlock (struct wined3d_device_vk *device_vk)
bool	wined3d_device_vk_create_null_resources (struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
bool	wined3d_device_vk_create_null_views (struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
void	wined3d_device_vk_destroy_null_resources (struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
void	wined3d_device_vk_destroy_null_views (struct wined3d_device_vk *device_vk, struct wined3d_context_vk *context_vk)
void	wined3d_device_vk_uav_clear_state_init (struct wined3d_device_vk *device_vk)
void	wined3d_device_vk_uav_clear_state_cleanup (struct wined3d_device_vk *device_vk)
static struct wined3d_texture_vk *	wined3d_texture_vk (struct wined3d_texture *texture)
void	wined3d_texture_vk_barrier (struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
const VkDescriptorImageInfo *	wined3d_texture_vk_get_default_image_info (struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk)
HRESULT	wined3d_texture_vk_init (struct wined3d_texture_vk *texture_vk, struct wined3d_device *device, const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count, uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops)
void	wined3d_texture_vk_make_generic (struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk)
BOOL	wined3d_texture_vk_prepare_texture (struct wined3d_texture_vk *texture_vk, struct wined3d_context_vk *context_vk)
static struct wined3d_sampler_vk *	wined3d_sampler_vk (struct wined3d_sampler *sampler)
void	wined3d_sampler_vk_init (struct wined3d_sampler_vk *sampler_vk, struct wined3d_device *device, const struct wined3d_sampler_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops)
static struct wined3d_buffer_vk *	wined3d_buffer_vk (struct wined3d_buffer *buffer)
void	wined3d_buffer_vk_barrier (struct wined3d_buffer_vk *buffer_vk, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
const VkDescriptorBufferInfo *	wined3d_buffer_vk_get_buffer_info (struct wined3d_buffer_vk *buffer_vk)
HRESULT	wined3d_buffer_vk_init (struct wined3d_buffer_vk *buffer_vk, struct wined3d_device *device, const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data, void *parent, const struct wined3d_parent_ops *parent_ops)
static void	wined3d_resource_vk_barrier (struct wined3d_resource *resource, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
static struct wined3d_rendertarget_view_vk *	wined3d_rendertarget_view_vk (struct wined3d_rendertarget_view *view)
static void	wined3d_rendertarget_view_vk_barrier (struct wined3d_rendertarget_view_vk *rtv_vk, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
static VkImageView	wined3d_rendertarget_view_vk_get_image_view (struct wined3d_rendertarget_view_vk *rtv_vk, struct wined3d_context_vk *context_vk)
HRESULT	wined3d_rendertarget_view_vk_init (struct wined3d_rendertarget_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
static struct wined3d_shader_resource_view_vk *	wined3d_shader_resource_view_vk (struct wined3d_shader_resource_view *view)
static void	wined3d_shader_resource_view_vk_barrier (struct wined3d_shader_resource_view_vk *srv_vk, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
void	wined3d_shader_resource_view_vk_generate_mipmap (struct wined3d_shader_resource_view_vk *srv_vk, struct wined3d_context_vk *context_vk)
HRESULT	wined3d_shader_resource_view_vk_init (struct wined3d_shader_resource_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
void	wined3d_shader_resource_view_vk_update_buffer (struct wined3d_shader_resource_view_vk *view_vk, struct wined3d_context_vk *context_vk)
void	wined3d_shader_resource_view_vk_update_layout (struct wined3d_shader_resource_view_vk *srv_vk, VkImageLayout layout)
static struct wined3d_unordered_access_view_vk *	wined3d_unordered_access_view_vk (struct wined3d_unordered_access_view *view)
static void	wined3d_unordered_access_view_vk_barrier (struct wined3d_unordered_access_view_vk *uav_vk, struct wined3d_context_vk *context_vk, uint32_t bind_mask)
void	wined3d_unordered_access_view_vk_clear (struct wined3d_unordered_access_view_vk *view_vk, const struct wined3d_uvec4 *clear_value, struct wined3d_context_vk *context_vk, bool fp)
HRESULT	wined3d_unordered_access_view_vk_init (struct wined3d_unordered_access_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops)
void	wined3d_unordered_access_view_vk_update (struct wined3d_unordered_access_view_vk *view_vk, struct wined3d_context_vk *context_vk)
static struct wined3d_swapchain_vk *	wined3d_swapchain_vk (struct wined3d_swapchain *swapchain)
void	wined3d_swapchain_vk_cleanup (struct wined3d_swapchain_vk *swapchain_vk)
HRESULT	wined3d_swapchain_vk_init (struct wined3d_swapchain_vk *swapchain_vk, struct wined3d_device *device, const struct wined3d_swapchain_desc *desc, struct wined3d_swapchain_state_parent *state_parent, void *parent, const struct wined3d_parent_ops *parent_ops)
static const struct wined3d_format_vk *	wined3d_format_vk (const struct wined3d_format *format)
static void	wined3d_context_vk_reference_bo (const struct wined3d_context_vk *context_vk, struct wined3d_bo_vk *bo)
static void	wined3d_context_vk_reference_image (const struct wined3d_context_vk *context_vk, struct wined3d_image_vk *image)
static void	wined3d_context_vk_reference_texture (const struct wined3d_context_vk *context_vk, struct wined3d_texture_vk *texture_vk)
static void	wined3d_context_vk_reference_resource (const struct wined3d_context_vk *context_vk, struct wined3d_resource *resource)
static void	wined3d_context_vk_reference_query (const struct wined3d_context_vk *context_vk, struct wined3d_query_vk *query_vk)
static void	wined3d_context_vk_reference_sampler (const struct wined3d_context_vk *context_vk, struct wined3d_sampler_vk *sampler_vk)
static void	wined3d_context_vk_reference_rendertarget_view (const struct wined3d_context_vk *context_vk, struct wined3d_rendertarget_view_vk *rtv_vk)
static void	wined3d_context_vk_reference_shader_resource_view (const struct wined3d_context_vk *context_vk, struct wined3d_shader_resource_view_vk *srv_vk)
static void	wined3d_context_vk_reference_unordered_access_view (const struct wined3d_context_vk *context_vk, struct wined3d_unordered_access_view_vk *uav_vk)

Variables
static const VkAccessFlags	WINED3D_READ_ONLY_ACCESS_FLAGS

Macro Definition Documentation

DECLARE_VK_PFN

#define DECLARE_VK_PFN

(

name

)

PFN_##name name;

Definition at line 217 of file wined3d_vk.h.

VK_CALL

#define VK_CALL

(

f

)

(vk_info->vk_ops.f)

Definition at line 272 of file wined3d_vk.h.

VK_DEVICE_EXT_PFN

#define VK_DEVICE_EXT_PFN   DECLARE_VK_PFN

Definition at line 224 of file wined3d_vk.h.

VK_DEVICE_FUNCS

#define VK_DEVICE_FUNCS

(

)

Definition at line 61 of file wined3d_vk.h.

VK_DEVICE_PFN

#define VK_DEVICE_PFN   DECLARE_VK_PFN

Definition at line 223 of file wined3d_vk.h.

VK_INSTANCE_EXT_PFN

#define VK_INSTANCE_EXT_PFN   DECLARE_VK_PFN

Definition at line 222 of file wined3d_vk.h.

VK_INSTANCE_FUNCS

#define VK_INSTANCE_FUNCS

(

)

Value:

    VK_INSTANCE_PFN(vkCreateDevice) \
    VK_INSTANCE_PFN(vkDestroyInstance) \
    VK_INSTANCE_PFN(vkEnumerateDeviceExtensionProperties) \
    VK_INSTANCE_PFN(vkEnumerateDeviceLayerProperties) \
    VK_INSTANCE_PFN(vkEnumeratePhysicalDevices) \
    VK_INSTANCE_PFN(vkGetDeviceProcAddr) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceFeatures) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceFormatProperties) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceImageFormatProperties) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceProperties) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceQueueFamilyProperties) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceSparseImageFormatProperties) \
    /* Vulkan 1.1 */ \
    VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceFeatures2) \
    VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceProperties2) \
    /* VK_KHR_surface */ \
    VK_INSTANCE_PFN(vkDestroySurfaceKHR) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR) \
    VK_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR) \
    /* VK_KHR_win32_surface */ \
    VK_INSTANCE_PFN(vkCreateWin32SurfaceKHR) \
    /* VK_EXT_host_query_reset */ \
    VK_INSTANCE_EXT_PFN(vkResetQueryPoolEXT)

Definition at line 33 of file wined3d_vk.h.

VK_INSTANCE_PFN

#define VK_INSTANCE_PFN   DECLARE_VK_PFN

Definition at line 221 of file wined3d_vk.h.

VK_NO_PROTOTYPES

#define VK_NO_PROTOTYPES

Definition at line 25 of file wined3d_vk.h.

WINED3D_FB_ATTACHMENT_FLAG_CLEAR_C

#define WINED3D_FB_ATTACHMENT_FLAG_CLEAR_C   2

Definition at line 485 of file wined3d_vk.h.

WINED3D_FB_ATTACHMENT_FLAG_CLEAR_S

#define WINED3D_FB_ATTACHMENT_FLAG_CLEAR_S   4

Definition at line 486 of file wined3d_vk.h.

WINED3D_FB_ATTACHMENT_FLAG_CLEAR_Z

#define WINED3D_FB_ATTACHMENT_FLAG_CLEAR_Z   8

Definition at line 487 of file wined3d_vk.h.

WINED3D_FB_ATTACHMENT_FLAG_DISCARDED

#define WINED3D_FB_ATTACHMENT_FLAG_DISCARDED   1

Definition at line 484 of file wined3d_vk.h.

WINED3D_QUERY_VK_FLAG_ACTIVE

#define WINED3D_QUERY_VK_FLAG_ACTIVE   0x00000001

Definition at line 389 of file wined3d_vk.h.

WINED3D_QUERY_VK_FLAG_RENDER_PASS

#define WINED3D_QUERY_VK_FLAG_RENDER_PASS   0x00000004

Definition at line 391 of file wined3d_vk.h.

WINED3D_QUERY_VK_FLAG_STARTED

#define WINED3D_QUERY_VK_FLAG_STARTED   0x00000002

Definition at line 390 of file wined3d_vk.h.

Enumeration Type Documentation

wined3d_retired_object_type_vk

enum wined3d_retired_object_type_vk

Enumerator
WINED3D_RETIRED_FREE_VK
WINED3D_RETIRED_FRAMEBUFFER_VK
WINED3D_RETIRED_DESCRIPTOR_POOL_VK
WINED3D_RETIRED_MEMORY_VK
WINED3D_RETIRED_ALLOCATOR_BLOCK_VK
WINED3D_RETIRED_BO_SLAB_SLICE_VK
WINED3D_RETIRED_BUFFER_VK
WINED3D_RETIRED_IMAGE_VK
WINED3D_RETIRED_BUFFER_VIEW_VK
WINED3D_RETIRED_IMAGE_VIEW_VK
WINED3D_RETIRED_SAMPLER_VK
WINED3D_RETIRED_QUERY_POOL_VK
WINED3D_RETIRED_EVENT_VK
WINED3D_RETIRED_PIPELINE_VK

Definition at line 426 of file wined3d_vk.h.

{
    WINED3D_RETIRED_FREE_VK,
    WINED3D_RETIRED_FRAMEBUFFER_VK,
    WINED3D_RETIRED_DESCRIPTOR_POOL_VK,
    WINED3D_RETIRED_MEMORY_VK,
    WINED3D_RETIRED_ALLOCATOR_BLOCK_VK,
    WINED3D_RETIRED_BO_SLAB_SLICE_VK,
    WINED3D_RETIRED_BUFFER_VK,
    WINED3D_RETIRED_IMAGE_VK,
    WINED3D_RETIRED_BUFFER_VIEW_VK,
    WINED3D_RETIRED_IMAGE_VIEW_VK,
    WINED3D_RETIRED_SAMPLER_VK,
    WINED3D_RETIRED_QUERY_POOL_VK,
    WINED3D_RETIRED_EVENT_VK,
    WINED3D_RETIRED_PIPELINE_VK,
};

wined3d_shader_descriptor_type

enum wined3d_shader_descriptor_type

Enumerator
WINED3D_SHADER_DESCRIPTOR_TYPE_CBV
WINED3D_SHADER_DESCRIPTOR_TYPE_SRV
WINED3D_SHADER_DESCRIPTOR_TYPE_UAV
WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER
WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER

Definition at line 555 of file wined3d_vk.h.

{
    WINED3D_SHADER_DESCRIPTOR_TYPE_CBV,
    WINED3D_SHADER_DESCRIPTOR_TYPE_SRV,
    WINED3D_SHADER_DESCRIPTOR_TYPE_UAV,
    WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER,
    WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER,
};

wined3d_vk_extension

enum wined3d_vk_extension

Enumerator
WINED3D_VK_EXT_NONE
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2
WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3
WINED3D_VK_EXT_HOST_QUERY_RESET
WINED3D_VK_EXT_SHADER_STENCIL_EXPORT
WINED3D_VK_EXT_TRANSFORM_FEEDBACK
WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR
WINED3D_VK_KHR_MAINTENANCE2
WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE
WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS
WINED3D_VK_EXT_COUNT

Definition at line 236 of file wined3d_vk.h.

{
    WINED3D_VK_EXT_NONE,
 
    WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE,
    WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE2,
    WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE3,
    WINED3D_VK_EXT_HOST_QUERY_RESET,
    WINED3D_VK_EXT_SHADER_STENCIL_EXPORT,
    WINED3D_VK_EXT_TRANSFORM_FEEDBACK,
    WINED3D_VK_EXT_VERTEX_ATTRIBUTE_DIVISOR,
    WINED3D_VK_KHR_MAINTENANCE2,
    WINED3D_VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE,
    WINED3D_VK_KHR_SHADER_DRAW_PARAMETERS,
 
    WINED3D_VK_EXT_COUNT,
};

Function Documentation

adapter_vk_copy_bo_address()

void adapter_vk_copy_bo_address	(	struct wined3d_context *	context,
		const struct wined3d_bo_address *	dst,
		const struct wined3d_bo_address *	src,
		unsigned int	range_count,
		const struct wined3d_range *	ranges,
		uint32_t	map_flags
	)

Definition at line 1020 of file adapter_vk.c.

{
    struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_bo_vk staging_bo, *src_bo, *dst_bo;
    VkAccessFlags src_access_mask, dst_access_mask;
    VkBufferMemoryBarrier vk_barrier[2];
    const struct wined3d_range *range;
    struct wined3d_bo_address staging;
    VkCommandBuffer vk_command_buffer;
    uint8_t *dst_ptr, *src_ptr;
    VkBufferCopy region;
    size_t size = 0;
    unsigned int i;
 
    src_bo = src->buffer_object ? wined3d_bo_vk(src->buffer_object) : NULL;
    dst_bo = dst->buffer_object ? wined3d_bo_vk(dst->buffer_object) : NULL;
 
    if (src_bo && dst_bo)
    {
        if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
        {
            ERR("Failed to get command buffer.\n");
            return;
        }
 
        wined3d_context_vk_end_current_render_pass(context_vk);
 
        src_access_mask = vk_access_mask_from_buffer_usage(src_bo->usage);
        dst_access_mask = vk_access_mask_from_buffer_usage(dst_bo->usage);
 
        vk_barrier[0].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        vk_barrier[0].pNext = NULL;
        vk_barrier[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier[0].buffer = src_bo->vk_buffer;
 
        vk_barrier[1].sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        vk_barrier[1].pNext = NULL;
        vk_barrier[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier[1].buffer = dst_bo->vk_buffer;
 
        for (i = 0; i < range_count; ++i)
        {
            range = &ranges[i];
 
            region.srcOffset = src_bo->b.buffer_offset + (uintptr_t)src->addr + range->offset;
            region.dstOffset = dst_bo->b.buffer_offset + (uintptr_t)dst->addr + range->offset;
            region.size = range->size;
 
            vk_barrier[0].offset = region.srcOffset;
            vk_barrier[0].size = region.size;
 
            vk_barrier[1].offset = region.dstOffset;
            vk_barrier[1].size = region.size;
 
            vk_barrier[0].srcAccessMask = src_access_mask;
            vk_barrier[0].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 
            vk_barrier[1].srcAccessMask = dst_access_mask;
            vk_barrier[1].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 
            VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                    VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
 
            VK_CALL(vkCmdCopyBuffer(vk_command_buffer, src_bo->vk_buffer, dst_bo->vk_buffer, 1, &region));
 
            vk_barrier[0].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
            vk_barrier[0].dstAccessMask = src_access_mask;
 
            vk_barrier[1].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
            vk_barrier[1].dstAccessMask = dst_access_mask;
 
            VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 2, vk_barrier, 0, NULL));
        }
 
        wined3d_context_vk_reference_bo(context_vk, src_bo);
        wined3d_context_vk_reference_bo(context_vk, dst_bo);
 
        return;
    }
 
    for (i = 0; i < range_count; ++i)
        size = max(size, ranges[i].offset + ranges[i].size);
 
    if (src_bo && !(src_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
    {
        if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
        {
            ERR("Failed to create staging bo.\n");
            return;
        }
 
        staging.buffer_object = &staging_bo.b;
        staging.addr = NULL;
        adapter_vk_copy_bo_address(context, &staging, src, range_count, ranges, WINED3D_MAP_WRITE);
        adapter_vk_copy_bo_address(context, dst, &staging, range_count, ranges, WINED3D_MAP_WRITE);
 
        wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
 
        return;
    }
 
    if (dst_bo && (!(dst_bo->memory_type & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) || (!(map_flags & WINED3D_MAP_DISCARD)
            && dst_bo->command_buffer_id > context_vk->completed_command_buffer_id)))
    {
        if (!(wined3d_context_vk_create_bo(context_vk, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &staging_bo)))
        {
            ERR("Failed to create staging bo.\n");
            return;
        }
 
        staging.buffer_object = &staging_bo.b;
        staging.addr = NULL;
        adapter_vk_copy_bo_address(context, &staging, src, range_count, ranges, WINED3D_MAP_WRITE);
        adapter_vk_copy_bo_address(context, dst, &staging, range_count, ranges, WINED3D_MAP_WRITE);
 
        wined3d_context_vk_destroy_bo(context_vk, &staging_bo);
 
        return;
    }
 
    src_ptr = adapter_vk_map_bo_address(context, src, size, WINED3D_MAP_READ);
    dst_ptr = adapter_vk_map_bo_address(context, dst, size, map_flags);
 
    for (i = 0; i < range_count; ++i)
        memcpy(dst_ptr + ranges[i].offset, src_ptr + ranges[i].offset, ranges[i].size);
 
    adapter_vk_unmap_bo_address(context, dst, range_count, ranges);
    adapter_vk_unmap_bo_address(context, src, 0, NULL);
}

Referenced by adapter_vk_copy_bo_address(), and wined3d_unordered_access_view_vk_clear().

vk_access_mask_from_bind_flags()

VkAccessFlags vk_access_mask_from_bind_flags

(

uint32_t

bind_flags

)

Definition at line 526 of file resource.c.

{
    VkAccessFlags flags = 0;
 
    if (bind_flags & WINED3D_BIND_VERTEX_BUFFER)
        flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
    if (bind_flags & WINED3D_BIND_INDEX_BUFFER)
        flags |= VK_ACCESS_INDEX_READ_BIT;
    if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER)
        flags |= VK_ACCESS_UNIFORM_READ_BIT;
    if (bind_flags & WINED3D_BIND_SHADER_RESOURCE)
        flags |= VK_ACCESS_SHADER_READ_BIT;
    if (bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
        flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
        flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
    if (bind_flags & WINED3D_BIND_RENDER_TARGET)
        flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
        flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
 
    return flags;
}

Referenced by vk_blitter_blit(), wined3d_buffer_vk_barrier(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_barrier(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_upload_data(), and wined3d_unordered_access_view_vk_clear().

vk_access_mask_from_buffer_usage()

VkAccessFlags vk_access_mask_from_buffer_usage

(

VkBufferUsageFlags

usage

)

Definition at line 835 of file adapter_vk.c.

{
    VkAccessFlags flags = 0;
 
    if (usage & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
        flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
    if (usage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
        flags |= VK_ACCESS_INDEX_READ_BIT;
    if (usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
        flags |= VK_ACCESS_UNIFORM_READ_BIT;
    if (usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)
        flags |= VK_ACCESS_SHADER_READ_BIT;
    if (usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
        flags |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
    if (usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
        flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
    if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT)
        flags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
    if (usage & VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT)
        flags |= VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
                | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
    if (usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
        flags |= VK_ACCESS_TRANSFER_READ_BIT;
    if (usage & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
        flags |= VK_ACCESS_TRANSFER_WRITE_BIT;
 
    return flags;
}

Referenced by adapter_vk_copy_bo_address(), adapter_vk_map_bo_address(), wined3d_texture_vk_download_data(), and wined3d_texture_vk_upload_data().

vk_aspect_mask_from_format()

static VkImageAspectFlags vk_aspect_mask_from_format ( const struct wined3d_format *  format )

inlinestatic

Definition at line 294 of file wined3d_vk.h.

{
    VkImageAspectFlags mask = 0;
 
    if (format->depth_size)
        mask |= VK_IMAGE_ASPECT_DEPTH_BIT;
    if (format->stencil_size)
        mask |= VK_IMAGE_ASPECT_STENCIL_BIT;
    if (!mask || format->red_size || format->green_size || format->blue_size || format->alpha_size)
        mask |= VK_IMAGE_ASPECT_COLOR_BIT;
 
    return mask;
}

Referenced by vk_blitter_blit(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_texture_vk_barrier(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_get_default_image_info(), wined3d_texture_vk_make_generic(), wined3d_texture_vk_prepare_texture(), wined3d_texture_vk_upload_data(), and wined3d_view_vk_create_vk_image_view().

vk_buffer_usage_from_bind_flags()

VkBufferUsageFlags vk_buffer_usage_from_bind_flags

(

uint32_t

bind_flags

)

Definition at line 1126 of file buffer.c.

{
    VkBufferUsageFlags usage;
 
    usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    if (bind_flags & WINED3D_BIND_VERTEX_BUFFER)
        usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
    if (bind_flags & WINED3D_BIND_INDEX_BUFFER)
        usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
    if (bind_flags & WINED3D_BIND_CONSTANT_BUFFER)
        usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
    if (bind_flags & WINED3D_BIND_SHADER_RESOURCE)
        usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
    if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
        usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
    if (bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
        usage |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
    if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
        usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
    if (bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_DEPTH_STENCIL))
        FIXME("Ignoring some bind flags %#x.\n", bind_flags);
    return usage;
}

Referenced by adapter_vk_alloc_bo(), and wined3d_buffer_vk_create_buffer_object().

vk_compare_op_from_wined3d()

VkCompareOp vk_compare_op_from_wined3d

(

enum wined3d_cmp_func

op

)

Definition at line 30 of file context_vk.c.

{
    switch (op)
    {
        case WINED3D_CMP_NEVER:
            return VK_COMPARE_OP_NEVER;
        case WINED3D_CMP_LESS:
            return VK_COMPARE_OP_LESS;
        case WINED3D_CMP_EQUAL:
            return VK_COMPARE_OP_EQUAL;
        case WINED3D_CMP_LESSEQUAL:
            return VK_COMPARE_OP_LESS_OR_EQUAL;
        case WINED3D_CMP_GREATER:
            return VK_COMPARE_OP_GREATER;
        case WINED3D_CMP_NOTEQUAL:
            return VK_COMPARE_OP_NOT_EQUAL;
        case WINED3D_CMP_GREATEREQUAL:
            return VK_COMPARE_OP_GREATER_OR_EQUAL;
        case WINED3D_CMP_ALWAYS:
            return VK_COMPARE_OP_ALWAYS;
        default:
            if (!op)
                WARN("Unhandled compare operation %#x.\n", op);
            else
                FIXME("Unhandled compare operation %#x.\n", op);
            return VK_COMPARE_OP_NEVER;
    }
}

Referenced by wined3d_context_vk_apply_draw_state(), wined3d_context_vk_update_graphics_pipeline_key(), and wined3d_sampler_vk_cs_init().

vk_image_view_type_from_wined3d()

VkImageViewType vk_image_view_type_from_wined3d	(	enum wined3d_resource_type	type,
		uint32_t	flags
	)

Definition at line 676 of file view.c.

{
    switch (type)
    {
        case WINED3D_RTYPE_TEXTURE_1D:
            if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
                return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
            else
                return VK_IMAGE_VIEW_TYPE_1D;
 
        case WINED3D_RTYPE_TEXTURE_2D:
            if (flags & WINED3D_VIEW_TEXTURE_CUBE)
            {
                if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
                    return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
                else
                    return VK_IMAGE_VIEW_TYPE_CUBE;
            }
            if (flags & WINED3D_VIEW_TEXTURE_ARRAY)
                return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
            else
                return VK_IMAGE_VIEW_TYPE_2D;
 
        case WINED3D_RTYPE_TEXTURE_3D:
            return VK_IMAGE_VIEW_TYPE_3D;
 
        default:
            ERR("Unhandled resource type %s.\n", debug_d3dresourcetype(type));
            return ~0u;
    }
}

Referenced by wined3d_texture_vk_get_default_image_info(), and wined3d_view_vk_create_vk_image_view().

vk_memory_type_from_access_flags()

VkMemoryPropertyFlags vk_memory_type_from_access_flags	(	uint32_t	access,
		uint32_t	usage
	)

Definition at line 1150 of file buffer.c.

{
    VkMemoryPropertyFlags memory_type = 0;
 
    if (access & WINED3D_RESOURCE_ACCESS_MAP_R)
        memory_type |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
    else if (access & WINED3D_RESOURCE_ACCESS_MAP_W)
        memory_type |= VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
    else if (!(usage & WINED3DUSAGE_DYNAMIC))
        memory_type |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    return memory_type;
}

Referenced by adapter_vk_alloc_bo(), and wined3d_buffer_vk_create_buffer_object().

vk_pipeline_stage_mask_from_bind_flags()

VkPipelineStageFlags vk_pipeline_stage_mask_from_bind_flags

(

uint32_t

bind_flags

)

Definition at line 552 of file resource.c.

{
    VkPipelineStageFlags flags = 0;
 
    if (bind_flags & (WINED3D_BIND_VERTEX_BUFFER | WINED3D_BIND_INDEX_BUFFER))
        flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    if (bind_flags & (WINED3D_BIND_CONSTANT_BUFFER | WINED3D_BIND_SHADER_RESOURCE | WINED3D_BIND_UNORDERED_ACCESS))
        flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
                | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
                | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
    if (bind_flags & WINED3D_BIND_INDIRECT_BUFFER)
        flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
    if (bind_flags & WINED3D_BIND_RENDER_TARGET)
        flags |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
    if (bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        flags |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    if (bind_flags & WINED3D_BIND_STREAM_OUTPUT)
        flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
 
    return flags;
}

Referenced by wined3d_buffer_vk_barrier(), wined3d_texture_vk_barrier(), and wined3d_unordered_access_view_vk_clear().

vk_pipeline_stage_mask_from_buffer_usage()

VkPipelineStageFlags vk_pipeline_stage_mask_from_buffer_usage

(

VkBufferUsageFlags

usage

)

Definition at line 864 of file adapter_vk.c.

{
    VkPipelineStageFlags flags = 0;
 
    if (usage & (VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT))
        flags |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    if (usage & (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
            | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT))
        flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
                | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
                | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
                | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;
    if (usage & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT)
        flags |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
    if (usage & (VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
            | VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT))
        flags |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
    if (usage & (VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT))
        flags |= VK_PIPELINE_STAGE_TRANSFER_BIT;
 
    return flags;
}

Referenced by wined3d_texture_vk_download_data(), and wined3d_texture_vk_upload_data().

vk_shader_stage_from_wined3d()

VkShaderStageFlagBits vk_shader_stage_from_wined3d

(

enum wined3d_shader_type

shader_type

)

Definition at line 59 of file context_vk.c.

{
    switch (shader_type)
    {
        case WINED3D_SHADER_TYPE_VERTEX:
            return VK_SHADER_STAGE_VERTEX_BIT;
        case WINED3D_SHADER_TYPE_HULL:
            return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
        case WINED3D_SHADER_TYPE_DOMAIN:
            return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
        case WINED3D_SHADER_TYPE_GEOMETRY:
            return VK_SHADER_STAGE_GEOMETRY_BIT;
        case WINED3D_SHADER_TYPE_PIXEL:
            return VK_SHADER_STAGE_FRAGMENT_BIT;
        case WINED3D_SHADER_TYPE_COMPUTE:
            return VK_SHADER_STAGE_COMPUTE_BIT;
        default:
            ERR("Unhandled shader type %s.\n", debug_shader_type(shader_type));
            return 0;
    }
}

Referenced by shader_spirv_resource_bindings_init(), and wined3d_context_vk_update_graphics_pipeline_key().

wined3d_adapter_vk()

static struct wined3d_adapter_vk * wined3d_adapter_vk ( struct wined3d_adapter *  adapter )

inlinestatic

Definition at line 737 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(adapter, struct wined3d_adapter_vk, a);
}

wined3d_adapter_vk_get_memory_type_index()

unsigned int wined3d_adapter_vk_get_memory_type_index	(	const struct wined3d_adapter_vk *	adapter_vk,
		uint32_t	memory_type_mask,
		VkMemoryPropertyFlags	flags
	)

Definition at line 1259 of file adapter_vk.c.

{
    const VkPhysicalDeviceMemoryProperties *memory_info = &adapter_vk->memory_properties;
    unsigned int i;
 
    for (i = 0; i < memory_info->memoryTypeCount; ++i)
    {
        if (!(memory_type_mask & (1u << i)))
            continue;
        if ((memory_info->memoryTypes[i].propertyFlags & flags) == flags)
            return i;
    }
 
    return ~0u;
}

Referenced by wined3d_context_vk_create_bo(), and wined3d_context_vk_create_image().

wined3d_adapter_vk_init_format_info()

BOOL wined3d_adapter_vk_init_format_info	(	struct wined3d_adapter_vk *	adapter_vk,
		const struct wined3d_vk_info *	vk_info
	)

Definition at line 4399 of file utils.c.

{
    VkPhysicalDevice vk_physical_device = adapter_vk->physical_device;
    struct wined3d_adapter *adapter = &adapter_vk->a;
    struct wined3d_format_vk *format;
    unsigned int i;
 
    if (!wined3d_adapter_init_format_info(adapter, sizeof(*format)))
        return FALSE;
 
    for (i = 0; i < WINED3D_FORMAT_COUNT; ++i)
    {
        format = wined3d_format_vk_mutable(get_format_by_idx(adapter, i));
 
        if (format->f.id)
            init_vulkan_format_info(format, vk_info, vk_physical_device);
    }
 
    if (!init_typeless_formats(adapter)) goto fail;
 
    return TRUE;
 
fail:
    free(adapter->formats);
    adapter->formats = NULL;
    return FALSE;
}

Referenced by wined3d_adapter_vk_init().

wined3d_allocator_chunk_vk()

static struct wined3d_allocator_chunk_vk * wined3d_allocator_chunk_vk ( struct wined3d_allocator_chunk *  chunk )

inlinestatic

Definition at line 783 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(chunk, struct wined3d_allocator_chunk_vk, c);
}

wined3d_allocator_chunk_vk_map()

void * wined3d_allocator_chunk_vk_map	(	struct wined3d_allocator_chunk_vk *	chunk_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 304 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    void *map_ptr;
    VkResult vr;
 
    TRACE("chunk %p, memory 0x%s, map_ptr %p.\n", chunk_vk,
            wine_dbgstr_longlong(chunk_vk->vk_memory), chunk_vk->c.map_ptr);
 
    wined3d_allocator_chunk_vk_lock(chunk_vk);
 
    if (!chunk_vk->c.map_ptr)
    {
        if ((vr = VK_CALL(vkMapMemory(device_vk->vk_device,
                chunk_vk->vk_memory, 0, VK_WHOLE_SIZE, 0, &chunk_vk->c.map_ptr))) < 0)
        {
            ERR("Failed to map chunk memory, vr %s.\n", wined3d_debug_vkresult(vr));
            wined3d_allocator_chunk_vk_unlock(chunk_vk);
            return NULL;
        }
 
        adapter_adjust_mapped_memory(device_vk->d.adapter, WINED3D_ALLOCATOR_CHUNK_SIZE);
    }
 
    ++chunk_vk->c.map_count;
    map_ptr = chunk_vk->c.map_ptr;
 
    wined3d_allocator_chunk_vk_unlock(chunk_vk);
 
    return map_ptr;
}

Referenced by wined3d_bo_vk_map().

wined3d_allocator_chunk_vk_unmap()

void wined3d_allocator_chunk_vk_unmap	(	struct wined3d_allocator_chunk_vk *	chunk_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 338 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
 
    TRACE("chunk_vk %p, context_vk %p.\n", chunk_vk, context_vk);
 
    wined3d_allocator_chunk_vk_lock(chunk_vk);
 
    if (--chunk_vk->c.map_count)
    {
        wined3d_allocator_chunk_vk_unlock(chunk_vk);
        return;
    }
 
    VK_CALL(vkUnmapMemory(device_vk->vk_device, chunk_vk->vk_memory));
    chunk_vk->c.map_ptr = NULL;
 
    wined3d_allocator_chunk_vk_unlock(chunk_vk);
 
    adapter_adjust_mapped_memory(device_vk->d.adapter, -WINED3D_ALLOCATOR_CHUNK_SIZE);
}

Referenced by wined3d_bo_vk_unmap(), and wined3d_context_vk_destroy_bo().

wined3d_bo_slab_vk_map()

void * wined3d_bo_slab_vk_map	(	struct wined3d_bo_slab_vk *	slab_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 796 of file adapter_vk.c.

{
    void *map_ptr;
 
    TRACE("slab_vk %p, context_vk %p.\n", slab_vk, context_vk);
 
    wined3d_bo_slab_vk_lock(slab_vk, context_vk);
 
    if (!slab_vk->map_ptr && !(slab_vk->map_ptr = wined3d_bo_vk_map(&slab_vk->bo, context_vk)))
    {
        wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
        ERR("Failed to map slab.\n");
        return NULL;
    }
 
    ++slab_vk->map_count;
    map_ptr = slab_vk->map_ptr;
 
    wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
 
    return map_ptr;
}

Referenced by wined3d_bo_vk_map().

wined3d_bo_slab_vk_unmap()

void wined3d_bo_slab_vk_unmap	(	struct wined3d_bo_slab_vk *	slab_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 819 of file adapter_vk.c.

{
    wined3d_bo_slab_vk_lock(slab_vk, context_vk);
 
    if (--slab_vk->map_count)
    {
        wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
        return;
    }
 
    wined3d_bo_vk_unmap(&slab_vk->bo, context_vk);
    slab_vk->map_ptr = NULL;
 
    wined3d_bo_slab_vk_unlock(slab_vk, context_vk);
}

Referenced by wined3d_bo_vk_unmap(), and wined3d_context_vk_destroy_bo().

wined3d_bo_vk()

static struct wined3d_bo_vk * wined3d_bo_vk ( struct wined3d_bo *  bo )

inlinestatic

Definition at line 326 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(bo, struct wined3d_bo_vk, b);
}

wined3d_buffer_vk()

static struct wined3d_buffer_vk * wined3d_buffer_vk ( struct wined3d_buffer *  buffer )

inlinestatic

Definition at line 926 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(buffer, struct wined3d_buffer_vk, b);
}

wined3d_buffer_vk_barrier()

void wined3d_buffer_vk_barrier	(	struct wined3d_buffer_vk *	buffer_vk,
		struct wined3d_context_vk *	context_vk,
		uint32_t	bind_mask
	)

Definition at line 1280 of file buffer.c.

{
    uint32_t src_bind_mask = 0;
 
    TRACE("buffer_vk %p, context_vk %p, bind_mask %s.\n",
            buffer_vk, context_vk, wined3d_debug_bind_flags(bind_mask));
 
    if (bind_mask & ~WINED3D_READ_ONLY_BIND_MASK)
    {
        src_bind_mask = buffer_vk->bind_mask & WINED3D_READ_ONLY_BIND_MASK;
        if (!src_bind_mask)
            src_bind_mask = buffer_vk->bind_mask;
 
        buffer_vk->bind_mask = bind_mask;
    }
    else if ((buffer_vk->bind_mask & bind_mask) != bind_mask)
    {
        src_bind_mask = buffer_vk->bind_mask & ~WINED3D_READ_ONLY_BIND_MASK;
        buffer_vk->bind_mask |= bind_mask;
    }
 
    if (src_bind_mask)
    {
        const struct wined3d_bo_vk *bo = wined3d_bo_vk(buffer_vk->b.buffer_object);
        const struct wined3d_vk_info *vk_info = context_vk->vk_info;
        VkBufferMemoryBarrier vk_barrier;
 
        TRACE("    %s -> %s.\n",
                wined3d_debug_bind_flags(src_bind_mask), wined3d_debug_bind_flags(bind_mask));
 
        wined3d_context_vk_end_current_render_pass(context_vk);
 
        vk_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
        vk_barrier.pNext = NULL;
        vk_barrier.srcAccessMask = vk_access_mask_from_bind_flags(src_bind_mask);
        vk_barrier.dstAccessMask = vk_access_mask_from_bind_flags(bind_mask);
        vk_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        vk_barrier.buffer = bo->vk_buffer;
        vk_barrier.offset = bo->b.buffer_offset;
        vk_barrier.size = buffer_vk->b.resource.size;
        VK_CALL(vkCmdPipelineBarrier(wined3d_context_vk_get_command_buffer(context_vk),
                vk_pipeline_stage_mask_from_bind_flags(src_bind_mask),
                vk_pipeline_stage_mask_from_bind_flags(bind_mask),
                0, 0, NULL, 1, &vk_barrier, 0, NULL));
    }
}

Referenced by wined3d_context_vk_apply_compute_state(), wined3d_context_vk_load_buffers(), wined3d_context_vk_load_shader_resources(), and wined3d_resource_vk_barrier().

wined3d_buffer_vk_get_buffer_info()

const VkDescriptorBufferInfo * wined3d_buffer_vk_get_buffer_info

(

struct wined3d_buffer_vk *

buffer_vk

)

Definition at line 1187 of file buffer.c.

{
    struct wined3d_bo_vk *bo = wined3d_bo_vk(buffer_vk->b.buffer_object);
 
    if (buffer_vk->b.bo_user.valid)
        return &buffer_vk->buffer_info;
 
    buffer_vk->buffer_info.buffer = bo->vk_buffer;
    buffer_vk->buffer_info.offset = bo->b.buffer_offset;
    buffer_vk->buffer_info.range = buffer_vk->b.resource.size;
    wined3d_buffer_validate_user(&buffer_vk->b);
 
    return &buffer_vk->buffer_info;
}

Referenced by wined3d_context_vk_apply_draw_state(), wined3d_context_vk_bind_stream_output_buffers(), wined3d_context_vk_bind_vertex_buffers(), and wined3d_shader_descriptor_writes_vk_add_cbv_write().

wined3d_buffer_vk_init()

HRESULT wined3d_buffer_vk_init	(	struct wined3d_buffer_vk *	buffer_vk,
		struct wined3d_device *	device,
		const struct wined3d_buffer_desc *	desc,
		const struct wined3d_sub_resource_data *	data,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 1258 of file buffer.c.

{
    const struct wined3d_vk_info *vk_info = &wined3d_adapter_vk(device->adapter)->vk_info;
 
    TRACE("buffer_vk %p, device %p, desc %p, data %p, parent %p, parent_ops %p.\n",
            buffer_vk, device, desc, data, parent, parent_ops);
 
    if ((desc->bind_flags & WINED3D_BIND_STREAM_OUTPUT)
            && !vk_info->supported[WINED3D_VK_EXT_TRANSFORM_FEEDBACK])
    {
        WARN("The Vulkan implementation does not support transform feedback.\n");
        return WINED3DERR_INVALIDCALL;
    }
 
    if (desc->access & WINED3D_RESOURCE_ACCESS_GPU)
        buffer_vk->b.flags |= WINED3D_BUFFER_USE_BO;
 
    return wined3d_buffer_init(&buffer_vk->b, device, desc, data, parent, parent_ops, &wined3d_buffer_vk_ops);
}

Referenced by adapter_vk_create_buffer().

wined3d_context_vk()

static struct wined3d_context_vk * wined3d_context_vk ( struct wined3d_context *  context )

inlinestatic

Definition at line 662 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(context, struct wined3d_context_vk, c);
}

wined3d_context_vk_allocate_query()

bool wined3d_context_vk_allocate_query	(	struct wined3d_context_vk *	context_vk,
		enum wined3d_query_type	type,
		struct wined3d_query_pool_idx_vk *	pool_idx
	)

Definition at line 1623 of file context_vk.c.

{
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_query_pool_vk *pool_vk, *entry;
    struct wined3d_device_vk *device_vk;
    struct list *free_pools;
    VkResult vr;
    size_t idx;
 
    switch (type)
    {
        case WINED3D_QUERY_TYPE_OCCLUSION:
            free_pools = &context_vk->free_occlusion_query_pools;
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP:
            free_pools = &context_vk->free_timestamp_query_pools;
            break;
 
        case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
            free_pools = &context_vk->free_pipeline_statistics_query_pools;
            break;
 
        case WINED3D_QUERY_TYPE_SO_STATISTICS:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
            free_pools = &context_vk->free_stream_output_statistics_query_pools;
            break;
 
        default:
            FIXME("Unhandled query type %#x.\n", type);
            return false;
    }
 
    LIST_FOR_EACH_ENTRY_SAFE(pool_vk, entry, free_pools, struct wined3d_query_pool_vk, entry)
    {
        if (wined3d_query_pool_vk_allocate_query(pool_vk, &idx))
            goto done;
        list_remove(&pool_vk->entry);
        list_init(&pool_vk->entry);
    }
 
    if (!(pool_vk = calloc(1, sizeof(*pool_vk))))
        return false;
    if (!wined3d_query_pool_vk_init(pool_vk, context_vk, type, free_pools))
    {
        free(pool_vk);
        return false;
    }
 
    device_vk = wined3d_device_vk(context_vk->c.device);
 
    if (vk_info->supported[WINED3D_VK_EXT_HOST_QUERY_RESET])
    {
        VK_CALL(vkResetQueryPoolEXT(device_vk->vk_device,
                pool_vk->vk_query_pool, 0, WINED3D_QUERY_POOL_SIZE));
    }
    else
    {
        VkEventCreateInfo event_create_info;
 
        wined3d_context_vk_end_current_render_pass(context_vk);
        VK_CALL(vkCmdResetQueryPool(wined3d_context_vk_get_command_buffer(context_vk),
                pool_vk->vk_query_pool, 0, WINED3D_QUERY_POOL_SIZE));
 
        event_create_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
        event_create_info.pNext = NULL;
        event_create_info.flags = 0;
 
        /* We probably shouldn't call vkGetQueryPoolResults() without synchronizing with vkCmdResetQueryPool()
         * even if the query pool is freshly allocated. wined3d_query_vk_accumulate_data() will check this event
         * before returning results. */
        vr = VK_CALL(vkCreateEvent(device_vk->vk_device, &event_create_info, NULL, &pool_vk->vk_event));
        if (vr == VK_SUCCESS)
        {
            /* At which stage vkCmdResetQueryPool() executes? */
            VK_CALL(vkCmdSetEvent(wined3d_context_vk_get_command_buffer(context_vk), pool_vk->vk_event,
                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT));
        }
        else
        {
            ERR("Failed to create event, vr %s.\n", wined3d_debug_vkresult(vr));
        }
    }
 
    if (!wined3d_query_pool_vk_allocate_query(pool_vk, &idx))
    {
        wined3d_query_pool_vk_cleanup(pool_vk, context_vk);
        free(pool_vk);
        return false;
    }
 
done:
    pool_idx->pool_vk = pool_vk;
    pool_idx->idx = idx;
 
    return true;
}

Referenced by wined3d_context_vk_end_current_render_pass(), wined3d_context_vk_get_command_buffer(), wined3d_query_timestamp_vk_issue(), and wined3d_query_vk_issue().

wined3d_context_vk_allocate_vram_chunk_memory()

VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory	(	struct wined3d_context_vk *	context_vk,
		unsigned int	pool,
		size_t	size
	)

Definition at line 362 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkMemoryAllocateInfo allocate_info;
    VkDeviceMemory vk_memory;
    VkResult vr;
 
    allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocate_info.pNext = NULL;
    allocate_info.allocationSize = size;
    allocate_info.memoryTypeIndex = pool;
    if ((vr = VK_CALL(vkAllocateMemory(device_vk->vk_device, &allocate_info, NULL, &vk_memory))) < 0)
    {
        ERR("Failed to allocate memory, vr %s.\n", wined3d_debug_vkresult(vr));
        return VK_NULL_HANDLE;
    }
 
    return vk_memory;
}

Referenced by wined3d_allocator_vk_create_chunk(), and wined3d_context_vk_allocate_memory().

wined3d_context_vk_apply_compute_state()

VkCommandBuffer wined3d_context_vk_apply_compute_state	(	struct wined3d_context_vk *	context_vk,
		const struct wined3d_state *	state,
		struct wined3d_buffer_vk *	indirect_vk
	)

Definition at line 4080 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkCommandBuffer vk_command_buffer;
 
    wined3d_context_vk_end_current_render_pass(context_vk);
 
    if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_SHADER))
        context_vk->c.shader_update_mask |= 1u << WINED3D_SHADER_TYPE_COMPUTE;
 
    if (context_vk->c.shader_update_mask & (1u << WINED3D_SHADER_TYPE_COMPUTE))
    {
        device_vk->d.shader_backend->shader_apply_compute_state(device_vk->d.shader_priv, &context_vk->c, state);
        if (!context_vk->compute.vk_pipeline)
        {
            ERR("No compute pipeline set.\n");
            return VK_NULL_HANDLE;
        }
        context_vk->c.update_compute_shader_resource_bindings = 1;
        context_vk->c.update_compute_unordered_access_view_bindings = 1;
        context_vk->update_compute_pipeline = 1;
    }
 
    wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_COMPUTE);
 
    if (indirect_vk)
    {
        wined3d_buffer_load_location(&indirect_vk->b, &context_vk->c, WINED3D_LOCATION_BUFFER);
        wined3d_buffer_vk_barrier(indirect_vk, context_vk, WINED3D_BIND_INDIRECT_BUFFER);
    }
 
    if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
    {
        ERR("Failed to get command buffer.\n");
        return VK_NULL_HANDLE;
    }
 
    if (context_vk->update_compute_pipeline)
    {
        VK_CALL(vkCmdBindPipeline(vk_command_buffer,
                VK_PIPELINE_BIND_POINT_COMPUTE, context_vk->compute.vk_pipeline));
        context_vk->update_compute_pipeline = 0;
    }
 
    if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_CONSTANT_BUFFER)
            || wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING))
        context_vk->c.update_compute_shader_resource_bindings = 1;
    if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING))
        context_vk->c.update_compute_unordered_access_view_bindings = 1;
 
    if (context_vk->c.update_compute_shader_resource_bindings
            || context_vk->c.update_compute_unordered_access_view_bindings)
    {
        if (!wined3d_context_vk_update_descriptors(context_vk, vk_command_buffer, state, WINED3D_PIPELINE_COMPUTE))
        {
            ERR("Failed to update shader descriptors.\n");
            return VK_NULL_HANDLE;
        }
 
        context_vk->c.update_compute_shader_resource_bindings = 0;
        context_vk->c.update_compute_unordered_access_view_bindings = 0;
    }
 
    memset(context_vk->c.dirty_compute_states, 0, sizeof(context_vk->c.dirty_compute_states));
    context_vk->c.shader_update_mask &= ~(1u << WINED3D_SHADER_TYPE_COMPUTE);
 
    return vk_command_buffer;
}

Referenced by adapter_vk_dispatch_compute().

wined3d_context_vk_apply_draw_state()

VkCommandBuffer wined3d_context_vk_apply_draw_state	(	struct wined3d_context_vk *	context_vk,
		const struct wined3d_state *	state,
		struct wined3d_buffer_vk *	indirect_vk,
		bool	indexed
	)

Definition at line 3722 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_d3d_info *d3d_info = context_vk->c.d3d_info;
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    const struct wined3d_blend_state *b = state->blend_state;
    VkSampleCountFlagBits prev_sample_count, sample_count;
    bool dual_source_blend = b && b->dual_source;
    struct wined3d_rendertarget_view *dsv;
    struct wined3d_rendertarget_view *rtv;
    struct wined3d_buffer_vk *buffer_vk;
    VkCommandBuffer vk_command_buffer;
    unsigned int i, invalidate_rt = 0;
    uint32_t null_buffer_binding;
    bool invalidate_ds = false;
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)
            || dual_source_blend != context_vk->c.last_was_dual_source_blend)
    {
        context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_PIXEL);
        context_vk->c.last_was_dual_source_blend = dual_source_blend;
    }
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX)))
        context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_VERTEX);
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY)))
        context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_GEOMETRY);
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_HULL)))
        context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_HULL) | (1u << WINED3D_SHADER_TYPE_DOMAIN);
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN)))
        context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_DOMAIN);
 
    prev_sample_count = context_vk->sample_count;
    context_vk->sample_count = 0;
    for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i)
    {
        if (!(rtv = state->fb.render_targets[i]) || rtv->format->id == WINED3DFMT_NULL)
            continue;
 
        if (wined3d_blend_state_get_writemask(state->blend_state, i))
        {
            /* We handle clears at the beginning of the render pass, no need for an explicit clear
             * first. */
            wined3d_context_vk_prepare_used_rtv(context_vk, rtv);
            invalidate_rt |= (1 << i);
        }
        else
        {
            wined3d_rendertarget_view_prepare_location(rtv, &context_vk->c, rtv->resource->draw_binding);
        }
 
        sample_count = max(1, wined3d_resource_get_sample_count(rtv->resource));
        if (!context_vk->sample_count)
            context_vk->sample_count = sample_count;
        else if (context_vk->sample_count != sample_count)
            FIXME("Inconsistent sample counts (%u != %u).\n", context_vk->sample_count, sample_count);
    }
 
    if ((dsv = state->fb.depth_stencil))
    {
        if (wined3d_state_uses_depth_buffer(state))
            wined3d_context_vk_prepare_used_rtv(context_vk, dsv);
        else
            wined3d_rendertarget_view_prepare_location(dsv, &context_vk->c, dsv->resource->draw_binding);
 
        if (!state->depth_stencil_state || state->depth_stencil_state->writes_ds)
            invalidate_ds = true;
 
        sample_count = max(1, wined3d_resource_get_sample_count(dsv->resource));
        if (!context_vk->sample_count)
            context_vk->sample_count = sample_count;
        else if (context_vk->sample_count != sample_count)
            FIXME("Inconsistent sample counts (%u != %u).\n", context_vk->sample_count, sample_count);
    }
 
    if (!context_vk->sample_count)
        context_vk->sample_count = VK_SAMPLE_COUNT_1_BIT;
 
    if (context_vk->sample_count != prev_sample_count)
        context_vk->c.update_multisample_state = 1;
 
    if (context_vk->c.shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE))
    {
        device_vk->d.shader_backend->shader_apply_draw_state(device_vk->d.shader_priv, &context_vk->c, state);
        if (!context_vk->graphics.vk_pipeline_layout)
        {
            ERR("No pipeline layout set.\n");
            return VK_NULL_HANDLE;
        }
        context_vk->c.update_shader_resource_bindings = 1;
        context_vk->c.update_unordered_access_view_bindings = 1;
    }
 
    wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_GRAPHICS);
 
    wined3d_context_vk_load_buffers(context_vk, state, indirect_vk, indexed);
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER))
        wined3d_context_vk_end_current_render_pass(context_vk);
 
    if (!wined3d_context_vk_begin_render_pass(context_vk, state, vk_info))
    {
        ERR("Failed to begin render pass.\n");
        return VK_NULL_HANDLE;
    }
    vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
 
    while (invalidate_rt)
    {
        i = wined3d_bit_scan(&invalidate_rt);
        rtv = state->fb.render_targets[i];
        wined3d_rendertarget_view_validate_location(rtv, rtv->resource->draw_binding);
        wined3d_rendertarget_view_invalidate_location(rtv, ~rtv->resource->draw_binding);
    }
 
    if (invalidate_ds)
    {
        wined3d_rendertarget_view_validate_location(dsv, dsv->resource->draw_binding);
        wined3d_rendertarget_view_invalidate_location(dsv, ~dsv->resource->draw_binding);
    }
 
    if (wined3d_context_vk_update_graphics_pipeline_key(context_vk, state, context_vk->graphics.vk_pipeline_layout,
            &null_buffer_binding) || !context_vk->graphics.vk_pipeline)
    {
        if (!(context_vk->graphics.vk_pipeline = wined3d_context_vk_get_graphics_pipeline(context_vk)))
        {
            ERR("Failed to get graphics pipeline.\n");
            return VK_NULL_HANDLE;
        }
 
        VK_CALL(vkCmdBindPipeline(vk_command_buffer,
                VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline));
        if (null_buffer_binding != ~0u)
        {
            VkDeviceSize offset = 0;
            VK_CALL(vkCmdBindVertexBuffers(vk_command_buffer, null_buffer_binding, 1,
                    &device_vk->null_resources_vk.buffer_info.buffer, &offset));
        }
    }
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STENCIL_REF) && dsv)
    {
        VK_CALL(vkCmdSetStencilReference(vk_command_buffer, VK_STENCIL_FACE_FRONT_AND_BACK,
            state->stencil_ref & wined3d_mask_from_size(dsv->format->stencil_size)));
    }
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STREAMSRC))
        wined3d_context_vk_bind_vertex_buffers(context_vk, vk_command_buffer, state, vk_info);
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_STREAM_OUTPUT))
    {
        context_vk->update_stream_output = 1;
        context_vk->c.transform_feedback_paused = 0;
    }
    if (context_vk->c.transform_feedback_active && context_vk->update_stream_output)
    {
        wined3d_context_vk_bind_stream_output_buffers(context_vk, vk_command_buffer, state, vk_info);
        context_vk->update_stream_output = 0;
    }
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_INDEXBUFFER) && state->index_buffer)
    {
        const VkDescriptorBufferInfo *buffer_info;
        VkIndexType idx_type;
 
        if (state->index_format == WINED3DFMT_R16_UINT)
            idx_type = VK_INDEX_TYPE_UINT16;
        else
            idx_type = VK_INDEX_TYPE_UINT32;
        buffer_vk = wined3d_buffer_vk(state->index_buffer);
        buffer_info = wined3d_buffer_vk_get_buffer_info(buffer_vk);
        wined3d_context_vk_reference_bo(context_vk, wined3d_bo_vk(buffer_vk->b.buffer_object));
        VK_CALL(vkCmdBindIndexBuffer(vk_command_buffer, buffer_info->buffer,
                buffer_info->offset + state->index_offset, idx_type));
    }
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c,
            STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c,
            STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c,
            STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c,
            STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN))
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_GRAPHICS_SHADER_RESOURCE_BINDING))
        context_vk->c.update_shader_resource_bindings = 1;
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING))
        context_vk->c.update_unordered_access_view_bindings = 1;
 
    if (context_vk->c.update_shader_resource_bindings || context_vk->c.update_unordered_access_view_bindings)
    {
        if (!wined3d_context_vk_update_descriptors(context_vk, vk_command_buffer, state, WINED3D_PIPELINE_GRAPHICS))
        {
            ERR("Failed to update shader descriptors.\n");
            return VK_NULL_HANDLE;
        }
 
        context_vk->c.update_shader_resource_bindings = 0;
        context_vk->c.update_unordered_access_view_bindings = 0;
    }
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_BLEND_FACTOR))
        VK_CALL(vkCmdSetBlendConstants(vk_command_buffer, &state->blend_factor.r));
 
    if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_VIEWPORT)
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SCISSORRECT)
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_RASTERIZER))
    {
        unsigned int viewport_count = (context_vk->vk_info->multiple_viewports ? WINED3D_MAX_VIEWPORTS : 1);
        VkViewport viewports[WINED3D_MAX_VIEWPORTS];
        VkRect2D scissors[WINED3D_MAX_VIEWPORTS];
        unsigned int i;
 
        for (i = 0; i < viewport_count; ++i)
        {
            const struct wined3d_viewport *src_viewport = &state->viewports[i];
            VkViewport *viewport = &viewports[i];
            VkRect2D *scissor = &scissors[i];
 
            if (i >= state->viewport_count)
            {
                viewport->x = 0.0f;
                viewport->y = 0.0f;
                viewport->width = 1.0f;
                viewport->height = 1.0f;
                viewport->minDepth = 0.0f;
                viewport->maxDepth = 0.0f;
                memset(scissor, 0, sizeof(*scissor));
                continue;
            }
 
            viewport->x = src_viewport->x;
            viewport->y = src_viewport->y;
            viewport->width = src_viewport->width;
            viewport->height = src_viewport->height;
            viewport->minDepth = src_viewport->min_z;
            viewport->maxDepth = src_viewport->max_z;
 
            if (state->rasterizer_state && state->rasterizer_state->desc.scissor)
            {
                const RECT *r = &state->scissor_rects[i];
 
                if (i >= state->scissor_rect_count)
                {
                    memset(scissor, 0, sizeof(*scissor));
                    continue;
                }
 
                scissor->offset.x = r->left;
                scissor->offset.y = r->top;
                scissor->extent.width =  r->right - r->left;
                scissor->extent.height = r->bottom - r->top;
            }
            else
            {
                scissor->offset.x = src_viewport->x;
                scissor->offset.y = src_viewport->y;
                scissor->extent.width = src_viewport->width;
                scissor->extent.height = src_viewport->height;
            }
 
            /* Scissor offsets need to be non-negative (VUID-VkPipelineViewportStateCreateInfo-x-02821) */
            if (scissor->offset.x < 0)
                scissor->offset.x = 0;
            if (scissor->offset.y < 0)
                scissor->offset.y = 0;
            viewport->y += viewport->height;
            viewport->height = -viewport->height;
        }
 
        VK_CALL(vkCmdSetViewport(vk_command_buffer, 0, viewport_count, viewports));
        VK_CALL(vkCmdSetScissor(vk_command_buffer, 0, viewport_count, scissors));
    }
 
    if (vk_info->dynamic_state2 && context_vk->c.update_primitive_type)
    {
        VK_CALL(vkCmdSetPrimitiveTopologyEXT(vk_command_buffer, vk_topology_from_wined3d(state->primitive_type)));
        if (!(d3d_info->wined3d_creation_flags & WINED3D_NO_PRIMITIVE_RESTART))
            VK_CALL(vkCmdSetPrimitiveRestartEnableEXT(vk_command_buffer,
                    !wined3d_primitive_type_is_list(state->primitive_type)));
        context_vk->c.update_primitive_type = 0;
    }
 
    if (vk_info->dynamic_patch_vertex_count && context_vk->c.update_patch_vertex_count)
    {
        if (state->patch_vertex_count)
            VK_CALL(vkCmdSetPatchControlPointsEXT(vk_command_buffer, state->patch_vertex_count));
        context_vk->c.update_patch_vertex_count = 0;
    }
 
    if (vk_info->dynamic_multisample_state && context_vk->c.update_multisample_state)
    {
        unsigned int sample_count = context_vk->sample_count;
 
        VK_CALL(vkCmdSetAlphaToCoverageEnableEXT(vk_command_buffer,
                state->blend_state && state->blend_state->desc.alpha_to_coverage));
        VK_CALL(vkCmdSetRasterizationSamplesEXT(vk_command_buffer, sample_count));
        VK_CALL(vkCmdSetSampleMaskEXT(vk_command_buffer, sample_count, &state->sample_mask));
        context_vk->c.update_multisample_state = 0;
    }
 
    if (vk_info->dynamic_rasterizer_state && (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_RASTERIZER)
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY))))
        wined3d_context_vk_set_dynamic_rasterizer_state(context_vk, vk_command_buffer, vk_info, state);
 
    if (vk_info->dynamic_blend_state && (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_BLEND)
            || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)))
        wined3d_context_vk_set_dynamic_blend_state(context_vk, vk_command_buffer, vk_info, state);
 
    if (vk_info->supported[WINED3D_VK_EXT_EXTENDED_DYNAMIC_STATE]
            && (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_DEPTH_STENCIL)
                    || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)))
    {
        const struct wined3d_depth_stencil_state *d = state->depth_stencil_state;
 
        if (d)
        {
            VkBool32 stencil_enable = state->fb.depth_stencil && d->desc.stencil;
 
            VK_CALL(vkCmdSetDepthTestEnableEXT(vk_command_buffer, d->desc.depth));
            VK_CALL(vkCmdSetDepthWriteEnableEXT(vk_command_buffer, d->desc.depth_write));
            VK_CALL(vkCmdSetDepthCompareOpEXT(vk_command_buffer, vk_compare_op_from_wined3d(d->desc.depth_func)));
            VK_CALL(vkCmdSetStencilTestEnableEXT(vk_command_buffer, stencil_enable));
            if (stencil_enable)
            {
                VK_CALL(vkCmdSetStencilOpEXT(vk_command_buffer, VK_STENCIL_FACE_FRONT_BIT,
                        vk_stencil_op_from_wined3d(d->desc.front.fail_op),
                        vk_stencil_op_from_wined3d(d->desc.front.pass_op),
                        vk_stencil_op_from_wined3d(d->desc.front.depth_fail_op),
                        vk_compare_op_from_wined3d(d->desc.front.func)));
                VK_CALL(vkCmdSetStencilOpEXT(vk_command_buffer, VK_STENCIL_FACE_BACK_BIT,
                        vk_stencil_op_from_wined3d(d->desc.back.fail_op),
                        vk_stencil_op_from_wined3d(d->desc.back.pass_op),
                        vk_stencil_op_from_wined3d(d->desc.back.depth_fail_op),
                        vk_compare_op_from_wined3d(d->desc.back.func)));
                VK_CALL(vkCmdSetStencilCompareMask(vk_command_buffer,
                        VK_STENCIL_FACE_FRONT_AND_BACK, d->desc.stencil_read_mask));
                VK_CALL(vkCmdSetStencilWriteMask(vk_command_buffer,
                        VK_STENCIL_FACE_FRONT_AND_BACK, d->desc.stencil_write_mask));
            }
        }
        else
        {
            VK_CALL(vkCmdSetDepthTestEnableEXT(vk_command_buffer, VK_TRUE));
            VK_CALL(vkCmdSetDepthWriteEnableEXT(vk_command_buffer, VK_TRUE));
            VK_CALL(vkCmdSetDepthCompareOpEXT(vk_command_buffer, VK_COMPARE_OP_LESS));
            VK_CALL(vkCmdSetStencilTestEnableEXT(vk_command_buffer, VK_FALSE));
        }
    }
 
    memset(context_vk->c.dirty_graphics_states, 0, sizeof(context_vk->c.dirty_graphics_states));
    context_vk->c.shader_update_mask &= 1u << WINED3D_SHADER_TYPE_COMPUTE;
 
    return vk_command_buffer;
}

Referenced by adapter_vk_draw_primitive().

wined3d_context_vk_cleanup()

void wined3d_context_vk_cleanup

(

struct wined3d_context_vk *

context_vk

)

Definition at line 1725 of file context_vk.c.

{
    struct wined3d_command_buffer_vk *buffer = &context_vk->current_command_buffer;
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    unsigned int i;
 
    if (buffer->vk_command_buffer)
    {
        free_command_buffer(context_vk, buffer);
        buffer->vk_command_buffer = VK_NULL_HANDLE;
    }
 
    wined3d_context_vk_wait_command_buffer(context_vk, buffer->id - 1);
    context_vk->completed_command_buffer_id = buffer->id;
    for (i = 0; i < context_vk->completed.buffer_count; ++i)
        free_command_buffer(context_vk, &context_vk->completed.buffers[i]);
 
    free(context_vk->compute.bindings.bindings);
    free(context_vk->graphics.bindings.bindings);
    for (i = 0; i < context_vk->vk_descriptor_pool_count; ++i)
        VK_CALL(vkDestroyDescriptorPool(device_vk->vk_device, context_vk->vk_descriptor_pools[i], NULL));
    free(context_vk->vk_descriptor_pools);
    if (context_vk->vk_framebuffer)
        VK_CALL(vkDestroyFramebuffer(device_vk->vk_device, context_vk->vk_framebuffer, NULL));
    if (context_vk->vk_so_counter_bo.vk_buffer)
        wined3d_context_vk_destroy_bo(context_vk, &context_vk->vk_so_counter_bo);
    wined3d_context_vk_cleanup_resources(context_vk, VK_NULL_HANDLE);
    /* Destroy the command pool after cleaning up resources. In particular,
     * this needs to happen after all command buffers are freed, because
     * vkFreeCommandBuffers() requires a valid pool handle. */
    VK_CALL(vkDestroyCommandPool(device_vk->vk_device, context_vk->vk_command_pool, NULL));
    wined3d_context_vk_destroy_query_pools(context_vk, &context_vk->free_occlusion_query_pools);
    wined3d_context_vk_destroy_query_pools(context_vk, &context_vk->free_timestamp_query_pools);
    wined3d_context_vk_destroy_query_pools(context_vk, &context_vk->free_pipeline_statistics_query_pools);
    wined3d_context_vk_destroy_query_pools(context_vk, &context_vk->free_stream_output_statistics_query_pools);
    wine_rb_destroy(&context_vk->bo_slab_available, wined3d_context_vk_destroy_bo_slab, context_vk);
    free(context_vk->submitted.buffers);
    free(context_vk->completed.buffers);
    free(context_vk->retired.objects);
 
    wined3d_shader_descriptor_writes_vk_cleanup(&context_vk->descriptor_writes);
    wine_rb_destroy(&context_vk->graphics_pipelines, wined3d_context_vk_destroy_graphics_pipeline, context_vk);
    wine_rb_destroy(&context_vk->pipeline_layouts, wined3d_context_vk_destroy_pipeline_layout, context_vk);
    wine_rb_destroy(&context_vk->render_passes, wined3d_context_vk_destroy_render_pass, context_vk);
 
    wined3d_context_cleanup(&context_vk->c);
}

Referenced by adapter_vk_init_3d(), and adapter_vk_uninit_3d().

wined3d_context_vk_create_bo()

BOOL wined3d_context_vk_create_bo	(	struct wined3d_context_vk *	context_vk,
		VkDeviceSize	size,
		VkBufferUsageFlags	usage,
		VkMemoryPropertyFlags	memory_type,
		struct wined3d_bo_vk *	bo
	)

Definition at line 528 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkMemoryRequirements memory_requirements;
    struct wined3d_adapter_vk *adapter_vk;
    VkBufferCreateInfo create_info;
    unsigned int memory_type_idx;
    VkResult vr;
 
    if (wined3d_context_vk_create_slab_bo(context_vk, size, usage, memory_type, bo))
        return TRUE;
 
    adapter_vk = wined3d_adapter_vk(device_vk->d.adapter);
 
    create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    create_info.pNext = NULL;
    create_info.flags = 0;
    create_info.size = size;
    create_info.usage = usage;
    create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    create_info.queueFamilyIndexCount = 0;
    create_info.pQueueFamilyIndices = NULL;
 
    if ((vr = VK_CALL(vkCreateBuffer(device_vk->vk_device, &create_info, NULL, &bo->vk_buffer))) < 0)
    {
        ERR("Failed to create Vulkan buffer, vr %s.\n", wined3d_debug_vkresult(vr));
        return FALSE;
    }
 
    VK_CALL(vkGetBufferMemoryRequirements(device_vk->vk_device, bo->vk_buffer, &memory_requirements));
 
    memory_type_idx = wined3d_adapter_vk_get_memory_type_index(adapter_vk,
            memory_requirements.memoryTypeBits, memory_type);
    if (memory_type_idx == ~0u)
    {
        ERR("Failed to find suitable memory type.\n");
        VK_CALL(vkDestroyBuffer(device_vk->vk_device, bo->vk_buffer, NULL));
        return FALSE;
    }
    bo->memory = wined3d_context_vk_allocate_memory(context_vk,
            memory_type_idx, memory_requirements.size, &bo->vk_memory);
    if (!bo->vk_memory)
    {
        ERR("Failed to allocate buffer memory.\n");
        VK_CALL(vkDestroyBuffer(device_vk->vk_device, bo->vk_buffer, NULL));
        return FALSE;
    }
    bo->b.memory_offset = bo->memory ? bo->memory->offset : 0;
 
    if ((vr = VK_CALL(vkBindBufferMemory(device_vk->vk_device, bo->vk_buffer,
            bo->vk_memory, bo->b.memory_offset))) < 0)
    {
        ERR("Failed to bind buffer memory, vr %s.\n", wined3d_debug_vkresult(vr));
        if (bo->memory)
            wined3d_context_vk_free_memory(context_vk, bo->memory);
        else
            VK_CALL(vkFreeMemory(device_vk->vk_device, bo->vk_memory, NULL));
        VK_CALL(vkDestroyBuffer(device_vk->vk_device, bo->vk_buffer, NULL));
        return FALSE;
    }
 
    bo->b.refcount = 1;
    bo->b.client_map_count = 0;
    bo->b.map_ptr = NULL;
    bo->b.buffer_offset = 0;
    bo->size = size;
    bo->usage = usage;
    bo->memory_type = adapter_vk->memory_properties.memoryTypes[memory_type_idx].propertyFlags;
    bo->b.coherent = !!(bo->memory_type & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
    list_init(&bo->b.users);
    bo->command_buffer_id = 0;
    bo->slab = NULL;
    bo->host_synced = false;
 
    TRACE("Created buffer 0x%s, memory 0x%s for bo %p.\n",
            wine_dbgstr_longlong(bo->vk_buffer), wine_dbgstr_longlong(bo->vk_memory), bo);
 
    return TRUE;
}

Referenced by adapter_vk_alloc_bo(), adapter_vk_copy_bo_address(), adapter_vk_map_bo_address(), wined3d_buffer_vk_create_buffer_object(), wined3d_context_vk_bind_stream_output_buffers(), wined3d_context_vk_create_slab_bo(), wined3d_device_vk_create_null_resources(), wined3d_texture_vk_download_data(), wined3d_texture_vk_prepare_buffer_object(), wined3d_texture_vk_upload_data(), wined3d_unordered_access_view_vk_clear(), and wined3d_unordered_access_view_vk_cs_init().

wined3d_context_vk_create_image()

BOOL wined3d_context_vk_create_image	(	struct wined3d_context_vk *	context_vk,
		VkImageType	vk_image_type,
		VkImageUsageFlags	usage,
		VkFormat	vk_format,
		unsigned int	width,
		unsigned int	height,
		unsigned int	depth,
		unsigned int	sample_count,
		unsigned int	mip_levels,
		unsigned int	layer_count,
		unsigned int	flags,
		struct wined3d_image_vk *	image
	)

Definition at line 610 of file context_vk.c.

{
    struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk(context_vk->c.device->adapter);
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkMemoryRequirements memory_requirements;
    VkImageCreateInfo create_info;
    unsigned int memory_type_idx;
    VkResult vr;
 
    create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    create_info.pNext = NULL;
    create_info.flags = flags;
    create_info.imageType = vk_image_type;
    create_info.format = vk_format;
    create_info.extent.width = width;
    create_info.extent.height = height;
    create_info.extent.depth = depth;
    create_info.mipLevels = mip_levels;
    create_info.arrayLayers = layer_count;
    create_info.samples = sample_count;
    create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
    create_info.usage = usage;
    create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    create_info.queueFamilyIndexCount = 0;
    create_info.pQueueFamilyIndices = NULL;
    create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
    image->command_buffer_id = 0;
 
    vr = VK_CALL(vkCreateImage(device_vk->vk_device, &create_info, NULL, &image->vk_image));
    if (vr != VK_SUCCESS)
    {
        ERR("Failed to create image, vr %s.\n", wined3d_debug_vkresult(vr));
        image->vk_image = VK_NULL_HANDLE;
        return FALSE;
    }
 
    VK_CALL(vkGetImageMemoryRequirements(device_vk->vk_device, image->vk_image,
            &memory_requirements));
 
    memory_type_idx = wined3d_adapter_vk_get_memory_type_index(adapter_vk,
            memory_requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
    if (memory_type_idx == ~0u)
    {
        ERR("Failed to find suitable image memory type.\n");
        VK_CALL(vkDestroyImage(device_vk->vk_device, image->vk_image, NULL));
        image->vk_image = VK_NULL_HANDLE;
        return FALSE;
    }
 
    image->memory = wined3d_context_vk_allocate_memory(context_vk, memory_type_idx,
            memory_requirements.size, &image->vk_memory);
    if (!image->vk_memory)
    {
        ERR("Failed to allocate image memory.\n");
        VK_CALL(vkDestroyImage(device_vk->vk_device, image->vk_image, NULL));
        image->vk_image = VK_NULL_HANDLE;
        return FALSE;
    }
 
    vr = VK_CALL(vkBindImageMemory(device_vk->vk_device, image->vk_image, image->vk_memory,
            image->memory ? image->memory->offset : 0));
    if (vr != VK_SUCCESS)
    {
        VK_CALL(vkDestroyImage(device_vk->vk_device, image->vk_image, NULL));
        if (image->memory)
            wined3d_context_vk_free_memory(context_vk, image->memory);
        else
            VK_CALL(vkFreeMemory(device_vk->vk_device, image->vk_memory, NULL));
        ERR("Failed to bind image memory, vr %s.\n", wined3d_debug_vkresult(vr));
        image->memory = NULL;
        image->vk_memory = VK_NULL_HANDLE;
        image->vk_image = VK_NULL_HANDLE;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by vk_blitter_blit(), wined3d_null_image_vk_init(), and wined3d_texture_vk_prepare_texture().

wined3d_context_vk_create_vk_descriptor_set()

VkDescriptorSet wined3d_context_vk_create_vk_descriptor_set	(	struct wined3d_context_vk *	context_vk,
		VkDescriptorSetLayout	vk_set_layout
	)

Definition at line 3048 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct VkDescriptorSetAllocateInfo set_desc;
    VkDescriptorPool vk_descriptor_pool;
    VkDescriptorSet vk_descriptor_set;
    VkResult vr;
 
    if (!(vk_descriptor_pool = wined3d_context_vk_get_vk_descriptor_pool(context_vk)))
        return VK_NULL_HANDLE;
 
    set_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    set_desc.pNext = NULL;
    set_desc.descriptorPool = vk_descriptor_pool;
    set_desc.descriptorSetCount = 1;
    set_desc.pSetLayouts = &vk_set_layout;
    if ((vr = VK_CALL(vkAllocateDescriptorSets(device_vk->vk_device, &set_desc, &vk_descriptor_set))) >= 0)
        return vk_descriptor_set;
 
    if (vr == VK_ERROR_FRAGMENTED_POOL || vr == VK_ERROR_OUT_OF_POOL_MEMORY)
    {
        wined3d_context_vk_reset_vk_descriptor_pool(context_vk,
                vk_descriptor_pool, context_vk->current_command_buffer.id);
        context_vk->vk_descriptor_pools[0] = context_vk->vk_descriptor_pools[--context_vk->vk_descriptor_pool_count];
        if (!(vk_descriptor_pool = wined3d_context_vk_get_vk_descriptor_pool(context_vk)))
        {
            WARN("Failed to create descriptor pool.\n");
            return VK_NULL_HANDLE;
        }
 
        set_desc.descriptorPool = vk_descriptor_pool;
        if ((vr = VK_CALL(vkAllocateDescriptorSets(device_vk->vk_device, &set_desc, &vk_descriptor_set))) >= 0)
            return vk_descriptor_set;
    }
 
    WARN("Failed to allocate descriptor set, vr %s.\n", wined3d_debug_vkresult(vr));
 
    return VK_NULL_HANDLE;
}

Referenced by wined3d_context_vk_update_descriptors(), and wined3d_unordered_access_view_vk_clear().

wined3d_context_vk_destroy_allocator_block()

void wined3d_context_vk_destroy_allocator_block	(	struct wined3d_context_vk *	context_vk,
		struct wined3d_allocator_block *	block,
		uint64_t	command_buffer_id
	)

Definition at line 803 of file context_vk.c.

{
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        wined3d_context_vk_free_memory(context_vk, block);
        TRACE("Freed block %p.\n", block);
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking block %p.\n", block);
        return;
    }
 
    o->type = WINED3D_RETIRED_ALLOCATOR_BLOCK_VK;
    o->u.block = block;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_context_vk_destroy_bo(), and wined3d_context_vk_destroy_image().

wined3d_context_vk_destroy_bo()

void wined3d_context_vk_destroy_bo	(	struct wined3d_context_vk *	context_vk,
		const struct wined3d_bo_vk *	bo
	)

Definition at line 1106 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_bo_slab_vk *slab_vk;
    size_t object_size, idx;
 
    TRACE("context_vk %p, bo %p.\n", context_vk, bo);
 
    assert(list_empty(&bo->b.users));
 
    if (bo->command_buffer_id == context_vk->current_command_buffer.id)
        context_vk->retired_bo_size += bo->size;
 
    if ((slab_vk = bo->slab))
    {
        if (bo->b.map_ptr)
            wined3d_bo_slab_vk_unmap(slab_vk, context_vk);
        object_size = slab_vk->bo.size / 32;
        idx = bo->b.buffer_offset / object_size;
        wined3d_context_vk_destroy_bo_slab_slice(context_vk, slab_vk, idx, bo->command_buffer_id);
        return;
    }
 
    wined3d_context_vk_destroy_vk_buffer(context_vk, bo->vk_buffer, bo->command_buffer_id);
    if (bo->memory)
    {
        if (bo->b.map_ptr)
            wined3d_allocator_chunk_vk_unmap(wined3d_allocator_chunk_vk(bo->memory->chunk), context_vk);
        wined3d_context_vk_destroy_allocator_block(context_vk, bo->memory, bo->command_buffer_id);
        return;
    }
 
    if (bo->b.map_ptr)
    {
        VK_CALL(vkUnmapMemory(device_vk->vk_device, bo->vk_memory));
        adapter_adjust_mapped_memory(device_vk->d.adapter, -bo->size);
    }
    wined3d_context_vk_destroy_vk_memory(context_vk, bo->vk_memory, bo->command_buffer_id);
}

Referenced by adapter_vk_copy_bo_address(), adapter_vk_destroy_bo(), adapter_vk_map_bo_address(), wined3d_buffer_vk_unload_location(), wined3d_context_vk_cleanup(), wined3d_context_vk_destroy_bo_slab(), wined3d_device_vk_create_null_resources(), wined3d_device_vk_destroy_null_resources(), wined3d_texture_vk_download_data(), wined3d_texture_vk_unload_location(), wined3d_texture_vk_upload_data(), wined3d_unordered_access_view_vk_clear(), and wined3d_view_vk_destroy_object().

wined3d_context_vk_destroy_image()

void wined3d_context_vk_destroy_image	(	struct wined3d_context_vk *	context_vk,
		struct wined3d_image_vk *	image_vk
	)

Definition at line 1092 of file context_vk.c.

{
    wined3d_context_vk_destroy_vk_image(context_vk, image->vk_image, image->command_buffer_id);
    if (image->memory)
        wined3d_context_vk_destroy_allocator_block(context_vk, image->memory,
                image->command_buffer_id);
    else
        wined3d_context_vk_destroy_vk_memory(context_vk, image->vk_memory, image->command_buffer_id);
 
    image->vk_image = VK_NULL_HANDLE;
    image->vk_memory = VK_NULL_HANDLE;
    image->memory = NULL;
}

Referenced by vk_blitter_blit(), wined3d_device_vk_create_null_resources(), wined3d_device_vk_destroy_null_resources(), and wined3d_texture_vk_unload_location().

wined3d_context_vk_destroy_vk_buffer_view()

void wined3d_context_vk_destroy_vk_buffer_view	(	struct wined3d_context_vk *	context_vk,
		VkBufferView	vk_view,
		uint64_t	command_buffer_id
	)

Definition at line 931 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyBufferView(device_vk->vk_device, vk_view, NULL));
        TRACE("Destroyed buffer view 0x%s.\n", wine_dbgstr_longlong(vk_view));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking buffer view 0x%s.\n", wine_dbgstr_longlong(vk_view));
        return;
    }
 
    o->type = WINED3D_RETIRED_BUFFER_VIEW_VK;
    o->u.vk_buffer_view = vk_view;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_device_vk_destroy_null_views(), wined3d_shader_resource_view_vk_update_buffer(), wined3d_unordered_access_view_vk_clear(), wined3d_unordered_access_view_vk_update(), and wined3d_view_vk_destroy_object().

wined3d_context_vk_destroy_vk_event()

void wined3d_context_vk_destroy_vk_event	(	struct wined3d_context_vk *	context_vk,
		VkEvent	vk_event,
		uint64_t	command_buffer_id
	)

Definition at line 1067 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyEvent(device_vk->vk_device, vk_event, NULL));
        TRACE("Destroyed event 0x%s.\n", wine_dbgstr_longlong(vk_event));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking event 0x%s.\n", wine_dbgstr_longlong(vk_event));
        return;
    }
 
    o->type = WINED3D_RETIRED_EVENT_VK;
    o->u.vk_event = vk_event;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_query_event_vk_issue(), and wined3d_query_vk_destroy().

wined3d_context_vk_destroy_vk_framebuffer()

void wined3d_context_vk_destroy_vk_framebuffer	(	struct wined3d_context_vk *	context_vk,
		VkFramebuffer	vk_framebuffer,
		uint64_t	command_buffer_id
	)

Definition at line 712 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyFramebuffer(device_vk->vk_device, vk_framebuffer, NULL));
        TRACE("Destroyed framebuffer 0x%s.\n", wine_dbgstr_longlong(vk_framebuffer));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking framebuffer 0x%s.\n", wine_dbgstr_longlong(vk_framebuffer));
        return;
    }
 
    o->type = WINED3D_RETIRED_FRAMEBUFFER_VK;
    o->u.vk_framebuffer = vk_framebuffer;
    o->command_buffer_id = command_buffer_id;
}

Referenced by vk_blitter_clear_rendertargets(), and wined3d_context_vk_end_current_render_pass().

wined3d_context_vk_destroy_vk_image()

void wined3d_context_vk_destroy_vk_image	(	struct wined3d_context_vk *	context_vk,
		VkImage	vk_image,
		uint64_t	command_buffer_id
	)

Definition at line 906 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyImage(device_vk->vk_device, vk_image, NULL));
        TRACE("Destroyed image 0x%s.\n", wine_dbgstr_longlong(vk_image));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking image 0x%s.\n", wine_dbgstr_longlong(vk_image));
        return;
    }
 
    o->type = WINED3D_RETIRED_IMAGE_VK;
    o->u.vk_image = vk_image;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_context_vk_destroy_image().

wined3d_context_vk_destroy_vk_image_view()

void wined3d_context_vk_destroy_vk_image_view	(	struct wined3d_context_vk *	context_vk,
		VkImageView	vk_view,
		uint64_t	command_buffer_id
	)

Definition at line 956 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyImageView(device_vk->vk_device, vk_view, NULL));
        TRACE("Destroyed image view 0x%s.\n", wine_dbgstr_longlong(vk_view));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking image view 0x%s.\n", wine_dbgstr_longlong(vk_view));
        return;
    }
 
    o->type = WINED3D_RETIRED_IMAGE_VIEW_VK;
    o->u.vk_image_view = vk_view;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_device_vk_destroy_null_views(), wined3d_texture_vk_unload_location(), wined3d_unordered_access_view_vk_clear(), and wined3d_view_vk_destroy_object().

wined3d_context_vk_destroy_vk_memory()

void wined3d_context_vk_destroy_vk_memory	(	struct wined3d_context_vk *	context_vk,
		VkDeviceMemory	vk_memory,
		uint64_t	command_buffer_id
	)

Definition at line 778 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkFreeMemory(device_vk->vk_device, vk_memory, NULL));
        TRACE("Freed memory 0x%s.\n", wine_dbgstr_longlong(vk_memory));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking memory 0x%s.\n", wine_dbgstr_longlong(vk_memory));
        return;
    }
 
    o->type = WINED3D_RETIRED_MEMORY_VK;
    o->u.vk_memory = vk_memory;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_context_vk_destroy_bo(), and wined3d_context_vk_destroy_image().

wined3d_context_vk_destroy_vk_pipeline()

void wined3d_context_vk_destroy_vk_pipeline	(	struct wined3d_context_vk *	context_vk,
		VkPipeline	vk_pipeline,
		uint64_t	command_buffer_id
	)

Definition at line 1016 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroyPipeline(device_vk->vk_device, vk_pipeline, NULL));
        TRACE("Destroyed pipeline 0x%s.\n", wine_dbgstr_longlong(vk_pipeline));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking pipeline 0x%s.\n", wine_dbgstr_longlong(vk_pipeline));
        return;
    }
 
    o->type = WINED3D_RETIRED_PIPELINE_VK;
    o->u.vk_pipeline = vk_pipeline;
    o->command_buffer_id = command_buffer_id;
}

Referenced by shader_spirv_destroy_compute_vk().

wined3d_context_vk_destroy_vk_sampler()

void wined3d_context_vk_destroy_vk_sampler	(	struct wined3d_context_vk *	context_vk,
		VkSampler	vk_sampler,
		uint64_t	command_buffer_id
	)

Definition at line 1042 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_retired_object_vk *o;
 
    if (context_vk->completed_command_buffer_id >= command_buffer_id)
    {
        VK_CALL(vkDestroySampler(device_vk->vk_device, vk_sampler, NULL));
        TRACE("Destroyed sampler 0x%s.\n", wine_dbgstr_longlong(vk_sampler));
        return;
    }
 
    if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
    {
        ERR("Leaking sampler 0x%s.\n", wine_dbgstr_longlong(vk_sampler));
        return;
    }
 
    o->type = WINED3D_RETIRED_SAMPLER_VK;
    o->u.vk_sampler = vk_sampler;
    o->command_buffer_id = command_buffer_id;
}

Referenced by wined3d_sampler_vk_destroy_object().

wined3d_context_vk_end_current_render_pass()

void wined3d_context_vk_end_current_render_pass

(

struct wined3d_context_vk *

context_vk

)

Definition at line 1564 of file context_vk.c.

{
    VkCommandBuffer vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_query_vk *query_vk;
 
    if (context_vk->vk_render_pass)
    {
        LIST_FOR_EACH_ENTRY(query_vk, &context_vk->render_pass_queries, struct wined3d_query_vk, entry)
            wined3d_query_vk_suspend(query_vk, context_vk);
 
        VK_CALL(vkCmdEndRenderPass(vk_command_buffer));
        context_vk->vk_render_pass = VK_NULL_HANDLE;
        VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, NULL, 0, NULL, 0, NULL));
 
        LIST_FOR_EACH_ENTRY(query_vk, &context_vk->render_pass_queries, struct wined3d_query_vk, entry)
        {
            if (!wined3d_context_vk_allocate_query(context_vk, query_vk->q.type, &query_vk->pool_idx))
            {
                ERR("Failed to allocate new query.\n");
                break;
            }
        }
    }
 
    if (context_vk->vk_framebuffer)
    {
        wined3d_context_vk_destroy_vk_framebuffer(context_vk,
                context_vk->vk_framebuffer, context_vk->current_command_buffer.id);
        context_vk->vk_framebuffer = VK_NULL_HANDLE;
    }
}

Referenced by adapter_vk_copy_bo_address(), adapter_vk_map_bo_address(), vk_blitter_clear_rendertargets(), wined3d_buffer_vk_barrier(), wined3d_context_vk_allocate_query(), wined3d_context_vk_apply_compute_state(), wined3d_context_vk_apply_draw_state(), wined3d_context_vk_image_barrier(), wined3d_context_vk_prepare_used_rtv(), wined3d_context_vk_submit_command_buffer(), wined3d_query_event_vk_issue(), wined3d_query_vk_issue(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_upload_data(), wined3d_unordered_access_view_vk_clear(), and wined3d_unordered_access_view_vk_cs_init().

wined3d_context_vk_get_command_buffer()

VkCommandBuffer wined3d_context_vk_get_command_buffer

(

struct wined3d_context_vk *

context_vk

)

Definition at line 1805 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_command_buffer_vk *buffer;
    VkCommandBufferBeginInfo begin_info;
    struct wined3d_query_vk *query_vk;
    VkResult vr;
 
    TRACE("context_vk %p.\n", context_vk);
 
    buffer = &context_vk->current_command_buffer;
    if (buffer->vk_command_buffer)
    {
        if (context_vk->retired_bo_size > WINED3D_RETIRED_BO_SIZE_THRESHOLD || should_periodic_submit(context_vk))
            wined3d_context_vk_submit_command_buffer(context_vk, 0, NULL, NULL, 0, NULL);
        else
        {
            TRACE("Returning existing command buffer %p with id 0x%s.\n",
                    buffer->vk_command_buffer, wine_dbgstr_longlong(buffer->id));
            return buffer->vk_command_buffer;
        }
    }
 
    if (context_vk->completed.buffer_count)
    {
        const struct wined3d_command_buffer_vk *old_buffer;
 
        old_buffer = &context_vk->completed.buffers[--context_vk->completed.buffer_count];
        buffer->vk_command_buffer = old_buffer->vk_command_buffer;
        buffer->vk_fence = old_buffer->vk_fence;
    }
    else
    {
        VkCommandBufferAllocateInfo command_buffer_info;
        VkFenceCreateInfo fence_desc;
 
        fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        fence_desc.pNext = NULL;
        fence_desc.flags = 0;
        if ((vr = VK_CALL(vkCreateFence(device_vk->vk_device, &fence_desc, NULL, &buffer->vk_fence))) < 0)
        {
            ERR("Failed to create fence, vr %s.\n", wined3d_debug_vkresult(vr));
            return VK_NULL_HANDLE;
        }
 
        command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        command_buffer_info.pNext = NULL;
        command_buffer_info.commandPool = context_vk->vk_command_pool;
        command_buffer_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        command_buffer_info.commandBufferCount = 1;
        if ((vr = VK_CALL(vkAllocateCommandBuffers(device_vk->vk_device,
                &command_buffer_info, &buffer->vk_command_buffer))) < 0)
        {
            WARN("Failed to allocate Vulkan command buffer, vr %s.\n", wined3d_debug_vkresult(vr));
            VK_CALL(vkDestroyFence(device_vk->vk_device, buffer->vk_fence, NULL));
            return VK_NULL_HANDLE;
        }
    }
 
    begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    begin_info.pNext = NULL;
    begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    begin_info.pInheritanceInfo = NULL;
    if ((vr = VK_CALL(vkBeginCommandBuffer(buffer->vk_command_buffer, &begin_info))) < 0)
    {
        WARN("Failed to begin command buffer, vr %s.\n", wined3d_debug_vkresult(vr));
        VK_CALL(vkFreeCommandBuffers(device_vk->vk_device, context_vk->vk_command_pool,
                1, &buffer->vk_command_buffer));
        return buffer->vk_command_buffer = VK_NULL_HANDLE;
    }
 
    LIST_FOR_EACH_ENTRY(query_vk, &context_vk->active_queries, struct wined3d_query_vk, entry)
    {
        if (!wined3d_context_vk_allocate_query(context_vk, query_vk->q.type, &query_vk->pool_idx))
        {
            ERR("Failed to allocate new query.\n");
            break;
        }
 
        wined3d_query_vk_resume(query_vk, context_vk);
    }
 
    context_vk->command_buffer_work_count = 0;
 
    TRACE("Created new command buffer %p with id 0x%s.\n",
            buffer->vk_command_buffer, wine_dbgstr_longlong(buffer->id));
 
    return buffer->vk_command_buffer;
}

Referenced by adapter_vk_copy_bo_address(), adapter_vk_map_bo_address(), vk_blitter_blit(), vk_blitter_clear_rendertargets(), wined3d_buffer_vk_barrier(), wined3d_context_vk_allocate_query(), wined3d_context_vk_apply_compute_state(), wined3d_context_vk_begin_render_pass(), wined3d_device_vk_create_null_resources(), wined3d_query_event_vk_issue(), wined3d_query_timestamp_vk_issue(), wined3d_query_vk_issue(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_barrier(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_make_generic(), wined3d_texture_vk_prepare_texture(), wined3d_texture_vk_upload_data(), wined3d_unordered_access_view_vk_clear(), and wined3d_unordered_access_view_vk_cs_init().

wined3d_context_vk_get_pipeline_layout()

struct wined3d_pipeline_layout_vk * wined3d_context_vk_get_pipeline_layout	(	struct wined3d_context_vk *	context_vk,
		VkDescriptorSetLayoutBinding *	bindings,
		SIZE_T	binding_count
	)

Definition at line 3442 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_pipeline_layout_key_vk key;
    struct wined3d_pipeline_layout_vk *layout;
    VkPipelineLayoutCreateInfo layout_desc;
    struct wine_rb_entry *entry;
    VkResult vr;
 
    key.bindings = bindings;
    key.binding_count = binding_count;
    if ((entry = wine_rb_get(&context_vk->pipeline_layouts, &key)))
        return WINE_RB_ENTRY_VALUE(entry, struct wined3d_pipeline_layout_vk, entry);
 
    if (!(layout = malloc(sizeof(*layout))))
        return NULL;
 
    if (!(layout->key.bindings = malloc(sizeof(*layout->key.bindings) * key.binding_count)))
    {
        free(layout);
        return NULL;
    }
    memcpy(layout->key.bindings, key.bindings, sizeof(*layout->key.bindings) * key.binding_count);
    layout->key.binding_count = key.binding_count;
 
    if ((vr = wined3d_context_vk_create_vk_descriptor_set_layout(device_vk, vk_info, &key, &layout->vk_set_layout)))
    {
        WARN("Failed to create descriptor set layout, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
 
    layout_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    layout_desc.pNext = NULL;
    layout_desc.flags = 0;
    layout_desc.setLayoutCount = 1;
    layout_desc.pSetLayouts = &layout->vk_set_layout;
    layout_desc.pushConstantRangeCount = 0;
    layout_desc.pPushConstantRanges = NULL;
 
    if ((vr = VK_CALL(vkCreatePipelineLayout(device_vk->vk_device,
            &layout_desc, NULL, &layout->vk_pipeline_layout))) < 0)
    {
        WARN("Failed to create Vulkan pipeline layout, vr %s.\n", wined3d_debug_vkresult(vr));
        VK_CALL(vkDestroyDescriptorSetLayout(device_vk->vk_device, layout->vk_set_layout, NULL));
        goto fail;
    }
 
    if (wine_rb_put(&context_vk->pipeline_layouts, &layout->key, &layout->entry) == -1)
    {
        ERR("Failed to insert pipeline layout.\n");
        VK_CALL(vkDestroyPipelineLayout(device_vk->vk_device, layout->vk_pipeline_layout, NULL));
        VK_CALL(vkDestroyDescriptorSetLayout(device_vk->vk_device, layout->vk_set_layout, NULL));
        goto fail;
    }
 
    return layout;
 
fail:
    free(layout->key.bindings);
    free(layout);
    return NULL;
}

Referenced by shader_spirv_apply_draw_state(), shader_spirv_find_compute_program_vk(), and wined3d_device_vk_uav_clear_state_init().

wined3d_context_vk_get_render_pass()

VkRenderPass wined3d_context_vk_get_render_pass	(	struct wined3d_context_vk *	context_vk,
		const struct wined3d_fb_state *	fb,
		unsigned int	rt_count,
		bool	depth_stencil,
		uint32_t	clear_flags
	)

Definition at line 1533 of file context_vk.c.

{
    struct wined3d_render_pass_key_vk key;
    struct wined3d_render_pass_vk *pass;
    struct wine_rb_entry *entry;
 
    wined3d_render_pass_key_vk_init(&key, fb, rt_count, depth_stencil, clear_flags);
    if ((entry = wine_rb_get(&context_vk->render_passes, &key)))
        return WINE_RB_ENTRY_VALUE(entry, struct wined3d_render_pass_vk, entry)->vk_render_pass;
 
    if (!(pass = malloc(sizeof(*pass))))
        return VK_NULL_HANDLE;
 
    if (!wined3d_render_pass_vk_init(pass, context_vk, &key))
    {
        free(pass);
        return VK_NULL_HANDLE;
    }
 
    if (wine_rb_put(&context_vk->render_passes, &pass->key, &pass->entry) == -1)
    {
        ERR("Failed to insert render pass.\n");
        wined3d_render_pass_vk_cleanup(pass, context_vk);
        free(pass);
        return VK_NULL_HANDLE;
    }
 
    return pass->vk_render_pass;
}

Referenced by vk_blitter_clear_rendertargets(), and wined3d_context_vk_begin_render_pass().

wined3d_context_vk_image_barrier()

void wined3d_context_vk_image_barrier	(	struct wined3d_context_vk *	context_vk,
		VkCommandBuffer	vk_command_buffer,
		VkPipelineStageFlags	src_stage_mask,
		VkPipelineStageFlags	dst_stage_mask,
		VkAccessFlags	src_access_mask,
		VkAccessFlags	dst_access_mask,
		VkImageLayout	old_layout,
		VkImageLayout	new_layout,
		VkImage	image,
		const VkImageSubresourceRange *	range
	)

Definition at line 2022 of file context_vk.c.

{
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkImageMemoryBarrier barrier;
 
    wined3d_context_vk_end_current_render_pass(context_vk);
 
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.pNext = NULL;
    barrier.srcAccessMask = src_access_mask;
    barrier.dstAccessMask = dst_access_mask;
    barrier.oldLayout = old_layout;
    barrier.newLayout = new_layout;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = image;
    barrier.subresourceRange = *range;
 
    VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, src_stage_mask, dst_stage_mask, 0, 0, NULL, 0, NULL, 1, &barrier));
}

Referenced by vk_blitter_blit(), wined3d_null_image_vk_init(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_barrier(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_make_generic(), wined3d_texture_vk_prepare_texture(), and wined3d_texture_vk_upload_data().

wined3d_context_vk_init()

HRESULT wined3d_context_vk_init	(	struct wined3d_context_vk *	context_vk,
		struct wined3d_swapchain *	swapchain
	)

Definition at line 4151 of file context_vk.c.

{
    VkCommandPoolCreateInfo command_pool_info;
    const struct wined3d_vk_info *vk_info;
    struct wined3d_adapter_vk *adapter_vk;
    struct wined3d_device_vk *device_vk;
    VkResult vr;
 
    TRACE("context_vk %p, swapchain %p.\n", context_vk, swapchain);
 
    memset(context_vk, 0, sizeof(*context_vk));
    wined3d_context_init(&context_vk->c, swapchain);
    device_vk = wined3d_device_vk(swapchain->device);
    adapter_vk = wined3d_adapter_vk(device_vk->d.adapter);
    context_vk->vk_info = vk_info = &adapter_vk->vk_info;
 
    command_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
    command_pool_info.pNext = NULL;
    command_pool_info.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
    command_pool_info.queueFamilyIndex = device_vk->vk_queue_family_index;
    if ((vr = VK_CALL(vkCreateCommandPool(device_vk->vk_device,
            &command_pool_info, NULL, &context_vk->vk_command_pool))) < 0)
    {
        ERR("Failed to create Vulkan command pool, vr %s.\n", wined3d_debug_vkresult(vr));
        wined3d_context_cleanup(&context_vk->c);
        return E_FAIL;
    }
    context_vk->current_command_buffer.id = 1;
 
    wined3d_context_vk_init_graphics_pipeline_key(context_vk);
 
    list_init(&context_vk->render_pass_queries);
    list_init(&context_vk->active_queries);
    list_init(&context_vk->completed_query_pools);
    list_init(&context_vk->free_occlusion_query_pools);
    list_init(&context_vk->free_timestamp_query_pools);
    list_init(&context_vk->free_pipeline_statistics_query_pools);
    list_init(&context_vk->free_stream_output_statistics_query_pools);
 
    wine_rb_init(&context_vk->render_passes, wined3d_render_pass_vk_compare);
    wine_rb_init(&context_vk->pipeline_layouts, wined3d_pipeline_layout_vk_compare);
    wine_rb_init(&context_vk->graphics_pipelines, wined3d_graphics_pipeline_vk_compare);
    wine_rb_init(&context_vk->bo_slab_available, wined3d_bo_slab_vk_compare);
 
    return WINED3D_OK;
}

Referenced by adapter_vk_init_3d().

wined3d_context_vk_reference_bo()

static void wined3d_context_vk_reference_bo ( const struct wined3d_context_vk *  context_vk, struct wined3d_bo_vk *  bo  )

inlinestatic

Definition at line 1091 of file wined3d_vk.h.

{
    bo->command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by adapter_vk_copy_bo_address(), adapter_vk_dispatch_compute(), adapter_vk_draw_primitive(), adapter_vk_map_bo_address(), wined3d_context_vk_apply_draw_state(), wined3d_context_vk_bind_stream_output_buffers(), wined3d_context_vk_bind_vertex_buffers(), wined3d_context_vk_reference_resource(), wined3d_device_vk_create_null_resources(), wined3d_device_vk_destroy_null_resources(), wined3d_shader_descriptor_writes_vk_add_cbv_write(), wined3d_texture_vk_download_data(), wined3d_texture_vk_upload_data(), wined3d_unordered_access_view_vk_clear(), and wined3d_unordered_access_view_vk_cs_init().

wined3d_context_vk_reference_image()

static void wined3d_context_vk_reference_image ( const struct wined3d_context_vk *  context_vk, struct wined3d_image_vk *  image  )

inlinestatic

Definition at line 1097 of file wined3d_vk.h.

{
    image->command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by vk_blitter_blit(), wined3d_context_vk_reference_texture(), wined3d_device_vk_destroy_null_resources(), and wined3d_null_image_vk_init().

wined3d_context_vk_reference_query()

static void wined3d_context_vk_reference_query ( const struct wined3d_context_vk *  context_vk, struct wined3d_query_vk *  query_vk  )

inlinestatic

Definition at line 1118 of file wined3d_vk.h.

{
    query_vk->command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by wined3d_query_event_vk_issue(), wined3d_query_timestamp_vk_issue(), and wined3d_query_vk_begin().

wined3d_context_vk_reference_rendertarget_view()

static void wined3d_context_vk_reference_rendertarget_view ( const struct wined3d_context_vk *  context_vk, struct wined3d_rendertarget_view_vk *  rtv_vk  )

inlinestatic

Definition at line 1130 of file wined3d_vk.h.

{
    wined3d_context_vk_reference_resource(context_vk, rtv_vk->v.resource);
    rtv_vk->command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by vk_blitter_clear_rendertargets(), and wined3d_context_vk_begin_render_pass().

wined3d_context_vk_reference_resource()

static void wined3d_context_vk_reference_resource ( const struct wined3d_context_vk *  context_vk, struct wined3d_resource *  resource  )

inlinestatic

Definition at line 1109 of file wined3d_vk.h.

{
    if (resource->type == WINED3D_RTYPE_BUFFER)
        wined3d_context_vk_reference_bo(context_vk, wined3d_bo_vk(buffer_from_resource(resource)->buffer_object));
    else
        wined3d_context_vk_reference_texture(context_vk, wined3d_texture_vk(texture_from_resource(resource)));
}

Referenced by wined3d_context_vk_reference_rendertarget_view(), wined3d_context_vk_reference_shader_resource_view(), and wined3d_context_vk_reference_unordered_access_view().

wined3d_context_vk_reference_sampler()

static void wined3d_context_vk_reference_sampler ( const struct wined3d_context_vk *  context_vk, struct wined3d_sampler_vk *  sampler_vk  )

inlinestatic

Definition at line 1124 of file wined3d_vk.h.

{
    sampler_vk->command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by wined3d_shader_descriptor_writes_vk_add_sampler_write().

wined3d_context_vk_reference_shader_resource_view()

static void wined3d_context_vk_reference_shader_resource_view ( const struct wined3d_context_vk *  context_vk, struct wined3d_shader_resource_view_vk *  srv_vk  )

inlinestatic

Definition at line 1137 of file wined3d_vk.h.

{
    wined3d_context_vk_reference_resource(context_vk, srv_vk->v.resource);
    srv_vk->view_vk.command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by wined3d_shader_descriptor_writes_vk_add_srv_write().

wined3d_context_vk_reference_texture()

static void wined3d_context_vk_reference_texture ( const struct wined3d_context_vk *  context_vk, struct wined3d_texture_vk *  texture_vk  )

inlinestatic

Definition at line 1103 of file wined3d_vk.h.

{
    wined3d_context_vk_reference_image(context_vk, &texture_vk->image);
}

Referenced by vk_blitter_blit(), wined3d_context_vk_reference_resource(), wined3d_shader_resource_view_vk_generate_mipmap(), wined3d_swapchain_vk_blit(), wined3d_texture_vk_clear(), wined3d_texture_vk_download_data(), wined3d_texture_vk_prepare_texture(), and wined3d_texture_vk_upload_data().

wined3d_context_vk_reference_unordered_access_view()

static void wined3d_context_vk_reference_unordered_access_view ( const struct wined3d_context_vk *  context_vk, struct wined3d_unordered_access_view_vk *  uav_vk  )

inlinestatic

Definition at line 1144 of file wined3d_vk.h.

{
    wined3d_context_vk_reference_resource(context_vk, uav_vk->v.resource);
    uav_vk->view_vk.command_buffer_id = context_vk->current_command_buffer.id;
}

Referenced by wined3d_shader_descriptor_writes_vk_add_uav_write(), and wined3d_unordered_access_view_vk_clear().

wined3d_context_vk_submit_command_buffer()

void wined3d_context_vk_submit_command_buffer	(	struct wined3d_context_vk *	context_vk,
		unsigned int	wait_semaphore_count,
		const VkSemaphore *	wait_semaphores,
		const VkPipelineStageFlags *	wait_stages,
		unsigned int	signal_semaphore_count,
		const VkSemaphore *	signal_semaphores
	)

Definition at line 1896 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    struct wined3d_query_pool_vk *pool_vk, *pool_vk_next;
    struct wined3d_command_buffer_vk *buffer;
    struct wined3d_query_vk *query_vk;
    VkSubmitInfo submit_info;
    VkResult vr;
 
    TRACE("context_vk %p, wait_semaphore_count %u, wait_semaphores %p, wait_stages %p,"
            "signal_semaphore_count %u, signal_semaphores %p.\n",
            context_vk, wait_semaphore_count, wait_semaphores, wait_stages,
            signal_semaphore_count, signal_semaphores);
 
    buffer = &context_vk->current_command_buffer;
    if (!buffer->vk_command_buffer)
        return;
 
    TRACE("Submitting command buffer %p with id 0x%s.\n",
            buffer->vk_command_buffer, wine_dbgstr_longlong(buffer->id));
 
    wined3d_context_vk_end_current_render_pass(context_vk);
 
    LIST_FOR_EACH_ENTRY_SAFE(pool_vk, pool_vk_next, &context_vk->completed_query_pools,
            struct wined3d_query_pool_vk, completed_entry)
    {
        list_remove(&pool_vk->completed_entry);
        list_init(&pool_vk->completed_entry);
 
        wined3d_context_vk_reset_completed_queries(context_vk, pool_vk, buffer);
    }
 
    LIST_FOR_EACH_ENTRY(query_vk, &context_vk->active_queries, struct wined3d_query_vk, entry)
        wined3d_query_vk_suspend(query_vk, context_vk);
 
    context_vk->graphics.vk_pipeline = VK_NULL_HANDLE;
    context_vk->update_compute_pipeline = 1;
    context_vk->update_stream_output = 1;
    context_vk->c.update_shader_resource_bindings = 1;
    context_vk->c.update_compute_shader_resource_bindings = 1;
    context_vk->c.update_unordered_access_view_bindings = 1;
    context_vk->c.update_compute_unordered_access_view_bindings = 1;
    context_vk->c.update_primitive_type = 1;
    context_vk->c.update_patch_vertex_count = 1;
    context_vk->c.update_multisample_state = 1;
    context_invalidate_state(&context_vk->c, STATE_STREAMSRC);
    context_invalidate_state(&context_vk->c, STATE_INDEXBUFFER);
    context_invalidate_state(&context_vk->c, STATE_BLEND);
    context_invalidate_state(&context_vk->c, STATE_BLEND_FACTOR);
    context_invalidate_state(&context_vk->c, STATE_DEPTH_STENCIL);
    context_invalidate_state(&context_vk->c, STATE_RASTERIZER);
    context_invalidate_state(&context_vk->c, STATE_STENCIL_REF);
    context_invalidate_state(&context_vk->c, STATE_VIEWPORT);
    context_invalidate_state(&context_vk->c, STATE_SCISSORRECT);
 
    VK_CALL(vkEndCommandBuffer(buffer->vk_command_buffer));
 
    VK_CALL(vkResetFences(device_vk->vk_device, 1, &buffer->vk_fence));
 
    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submit_info.pNext = NULL;
    submit_info.waitSemaphoreCount = wait_semaphore_count;
    submit_info.pWaitSemaphores = wait_semaphores;
    submit_info.pWaitDstStageMask = wait_stages;
    submit_info.commandBufferCount = 1;
    submit_info.pCommandBuffers = &buffer->vk_command_buffer;
    submit_info.signalSemaphoreCount = signal_semaphore_count;
    submit_info.pSignalSemaphores = signal_semaphores;
 
    if ((vr = VK_CALL(vkQueueSubmit(device_vk->vk_queue, 1, &submit_info, buffer->vk_fence))) < 0)
        ERR("Failed to submit command buffer %p, vr %s.\n",
                buffer->vk_command_buffer, wined3d_debug_vkresult(vr));
 
    if (!wined3d_array_reserve((void **)&context_vk->submitted.buffers, &context_vk->submitted.buffers_size,
            context_vk->submitted.buffer_count + 1, sizeof(*context_vk->submitted.buffers)))
        ERR("Failed to grow submitted command buffer array.\n");
 
    context_vk->submitted.buffers[context_vk->submitted.buffer_count++] = *buffer;
 
    buffer->vk_command_buffer = VK_NULL_HANDLE;
    /* We don't expect this to ever happen, but handle it anyway. */
    if (!++buffer->id)
    {
        wined3d_context_vk_wait_command_buffer(context_vk, buffer->id - 1);
        context_vk->completed_command_buffer_id = 0;
        buffer->id = 1;
    }
    context_vk->retired_bo_size = 0;
    wined3d_context_vk_cleanup_resources(context_vk, VK_NULL_HANDLE);
}

Referenced by adapter_vk_flush_context(), adapter_vk_map_bo_address(), wined3d_context_vk_get_command_buffer(), wined3d_swapchain_vk_blit(), and wined3d_texture_vk_download_data().

wined3d_context_vk_wait_command_buffer()

void wined3d_context_vk_wait_command_buffer	(	struct wined3d_context_vk *	context_vk,
		uint64_t	id
	)

Definition at line 1990 of file context_vk.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkFence vk_fence;
    SIZE_T i;
 
    if (id <= context_vk->completed_command_buffer_id
            || id > context_vk->current_command_buffer.id) /* In case the buffer ID wrapped. */
        return;
 
    for (i = 0; i < context_vk->submitted.buffer_count; ++i)
    {
        if (context_vk->submitted.buffers[i].id != id)
            continue;
 
        vk_fence = context_vk->submitted.buffers[i].vk_fence;
        wined3d_context_vk_cleanup_resources(context_vk, vk_fence);
        for (i = 0; i < context_vk->submitted.buffer_count; ++i)
        {
            if (context_vk->submitted.buffers[i].id != id)
                continue;
 
            VK_CALL(vkWaitForFences(device_vk->vk_device, 1, &vk_fence, VK_TRUE, UINT64_MAX));
            wined3d_context_vk_remove_command_buffer(context_vk, i);
            return;
        }
    }
 
    ERR("Failed to find fence for command buffer with id 0x%s.\n", wine_dbgstr_longlong(id));
}

Referenced by adapter_vk_map_bo_address(), wined3d_context_vk_cleanup(), wined3d_context_vk_submit_command_buffer(), wined3d_swapchain_vk_blit(), and wined3d_texture_vk_download_data().

wined3d_debug_vkresult()

const char * wined3d_debug_vkresult

(

VkResult

vr

)

Definition at line 5463 of file utils.c.

{
    switch (vr)
    {
#define WINED3D_TO_STR(x) case x: return #x
        WINED3D_TO_STR(VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR);
        WINED3D_TO_STR(VK_ERROR_NOT_PERMITTED_EXT);
        WINED3D_TO_STR(VK_ERROR_FRAGMENTATION_EXT);
        WINED3D_TO_STR(VK_ERROR_INVALID_EXTERNAL_HANDLE);
        WINED3D_TO_STR(VK_ERROR_OUT_OF_POOL_MEMORY);
        WINED3D_TO_STR(VK_ERROR_INVALID_SHADER_NV);
        WINED3D_TO_STR(VK_ERROR_OUT_OF_DATE_KHR);
        WINED3D_TO_STR(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
        WINED3D_TO_STR(VK_ERROR_SURFACE_LOST_KHR);
        WINED3D_TO_STR(VK_ERROR_FRAGMENTED_POOL);
        WINED3D_TO_STR(VK_ERROR_FORMAT_NOT_SUPPORTED);
        WINED3D_TO_STR(VK_ERROR_TOO_MANY_OBJECTS);
        WINED3D_TO_STR(VK_ERROR_INCOMPATIBLE_DRIVER);
        WINED3D_TO_STR(VK_ERROR_FEATURE_NOT_PRESENT);
        WINED3D_TO_STR(VK_ERROR_EXTENSION_NOT_PRESENT);
        WINED3D_TO_STR(VK_ERROR_LAYER_NOT_PRESENT);
        WINED3D_TO_STR(VK_ERROR_MEMORY_MAP_FAILED);
        WINED3D_TO_STR(VK_ERROR_DEVICE_LOST);
        WINED3D_TO_STR(VK_ERROR_INITIALIZATION_FAILED);
        WINED3D_TO_STR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
        WINED3D_TO_STR(VK_ERROR_OUT_OF_HOST_MEMORY);
        WINED3D_TO_STR(VK_SUCCESS);
        WINED3D_TO_STR(VK_NOT_READY);
        WINED3D_TO_STR(VK_TIMEOUT);
        WINED3D_TO_STR(VK_EVENT_SET);
        WINED3D_TO_STR(VK_EVENT_RESET);
        WINED3D_TO_STR(VK_INCOMPLETE);
        WINED3D_TO_STR(VK_SUBOPTIMAL_KHR);
#undef WINED3D_TO_STR
        default:
            return wine_dbg_sprintf("unrecognised(%d)", vr);
    }
}

Referenced by adapter_vk_create_device(), create_uav_pipeline(), enable_vulkan_instance_extensions(), get_vulkan_physical_device(), init_vulkan_format_info(), shader_spirv_compile_shader(), shader_spirv_find_compute_program_vk(), swapchain_vk_present(), vk_blitter_clear_rendertargets(), wined3d_adapter_vk_init_device_extensions(), wined3d_allocator_chunk_vk_map(), wined3d_bo_vk_map(), wined3d_context_vk_allocate_query(), wined3d_context_vk_allocate_vram_chunk_memory(), wined3d_context_vk_begin_render_pass(), wined3d_context_vk_create_bo(), wined3d_context_vk_create_image(), wined3d_context_vk_create_vk_descriptor_pool(), wined3d_context_vk_create_vk_descriptor_set(), wined3d_context_vk_create_vk_descriptor_set_layout(), wined3d_context_vk_get_command_buffer(), wined3d_context_vk_get_graphics_pipeline(), wined3d_context_vk_get_pipeline_layout(), wined3d_context_vk_get_vk_descriptor_pool(), wined3d_context_vk_init(), wined3d_context_vk_submit_command_buffer(), wined3d_device_vk_create_null_views(), wined3d_init_vulkan(), wined3d_query_event_vk_issue(), wined3d_query_pool_vk_init(), wined3d_query_vk_accumulate_data(), wined3d_sampler_vk_cs_init(), wined3d_swapchain_vk_blit(), wined3d_swapchain_vk_create_vulkan_swapchain(), wined3d_swapchain_vk_create_vulkan_swapchain_images(), wined3d_swapchain_vk_destroy_vulkan_swapchain(), wined3d_swapchain_vk_present_mode_supported(), wined3d_swapchain_vk_select_vk_format(), wined3d_texture_vk_get_default_image_info(), wined3d_unordered_access_view_vk_cs_init(), wined3d_view_vk_create_vk_buffer_view(), and wined3d_view_vk_create_vk_image_view().

wined3d_device_vk()

static struct wined3d_device_vk * wined3d_device_vk ( struct wined3d_device *  device )

inlinestatic

Definition at line 841 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(device, struct wined3d_device_vk, d);
}

wined3d_device_vk_allocator_lock()

static void wined3d_device_vk_allocator_lock ( struct wined3d_device_vk *  device_vk )

inlinestatic

Definition at line 851 of file wined3d_vk.h.

{
    EnterCriticalSection(&device_vk->allocator_cs);
}

Referenced by wined3d_allocator_chunk_vk_lock(), wined3d_bo_slab_vk_free_slice(), wined3d_bo_slab_vk_lock(), wined3d_context_vk_allocate_memory(), wined3d_context_vk_create_slab_bo(), and wined3d_context_vk_free_memory().

wined3d_device_vk_allocator_unlock()

static void wined3d_device_vk_allocator_unlock ( struct wined3d_device_vk *  device_vk )

inlinestatic

Definition at line 856 of file wined3d_vk.h.

{
    LeaveCriticalSection(&device_vk->allocator_cs);
}

Referenced by wined3d_allocator_chunk_vk_unlock(), wined3d_bo_slab_vk_free_slice(), wined3d_bo_slab_vk_unlock(), wined3d_context_vk_allocate_memory(), wined3d_context_vk_create_slab_bo(), and wined3d_context_vk_free_memory().

wined3d_device_vk_create_null_resources()

bool wined3d_device_vk_create_null_resources	(	struct wined3d_device_vk *	device_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 839 of file device.c.

{
    struct wined3d_null_resources_vk *r = &device_vk->null_resources_vk;
    const struct wined3d_vk_info *vk_info;
    const struct wined3d_format *format;
    VkMemoryPropertyFlags memory_type;
    VkCommandBuffer vk_command_buffer;
    unsigned int sample_count = 2;
    VkBufferUsageFlags usage;
 
    format = wined3d_get_format(device_vk->d.adapter, WINED3DFMT_R8G8B8A8_UNORM, WINED3D_BIND_SHADER_RESOURCE);
    while (sample_count && !(sample_count & format->multisample_types))
        sample_count <<= 1;
 
    if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
    {
        ERR("Failed to get command buffer.\n");
        return false;
    }
 
    vk_info = context_vk->vk_info;
 
    usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
            | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
    memory_type = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
    if (!wined3d_context_vk_create_bo(context_vk, 16, usage, memory_type, &r->bo))
        return false;
    VK_CALL(vkCmdFillBuffer(vk_command_buffer, r->bo.vk_buffer, r->bo.b.buffer_offset, r->bo.size, 0x00000000u));
    r->buffer_info.buffer = r->bo.vk_buffer;
    r->buffer_info.offset = r->bo.b.buffer_offset;
    r->buffer_info.range = r->bo.size;
 
    if (!wined3d_null_image_vk_init(&r->image_1d, context_vk, vk_command_buffer, VK_IMAGE_TYPE_1D, 1, 1))
    {
        ERR("Failed to create 1D image.\n");
        goto fail;
    }
 
    if (!wined3d_null_image_vk_init(&r->image_2d, context_vk, vk_command_buffer, VK_IMAGE_TYPE_2D, 6, 1))
    {
        ERR("Failed to create 2D image.\n");
        goto fail;
    }
 
    if (!wined3d_null_image_vk_init(&r->image_2dms, context_vk, vk_command_buffer, VK_IMAGE_TYPE_2D, 1, sample_count))
    {
        ERR("Failed to create 2D MSAA image.\n");
        goto fail;
    }
 
    if (!wined3d_null_image_vk_init(&r->image_3d, context_vk, vk_command_buffer, VK_IMAGE_TYPE_3D, 1, 1))
    {
        ERR("Failed to create 3D image.\n");
        goto fail;
    }
 
    return true;
 
fail:
    if (r->image_2dms.vk_image)
        wined3d_context_vk_destroy_image(context_vk, &r->image_2dms);
    if (r->image_2d.vk_image)
        wined3d_context_vk_destroy_image(context_vk, &r->image_2d);
    if (r->image_1d.vk_image)
        wined3d_context_vk_destroy_image(context_vk, &r->image_1d);
    wined3d_context_vk_reference_bo(context_vk, &r->bo);
    wined3d_context_vk_destroy_bo(context_vk, &r->bo);
    return false;
}

Referenced by adapter_vk_init_3d().

wined3d_device_vk_create_null_views()

bool wined3d_device_vk_create_null_views	(	struct wined3d_device_vk *	device_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 929 of file device.c.

{
    struct wined3d_null_resources_vk *r = &device_vk->null_resources_vk;
    struct wined3d_null_views_vk *v = &device_vk->null_views_vk;
    VkBufferViewCreateInfo buffer_create_info;
    VkImageViewUsageCreateInfoKHR usage_desc;
    const struct wined3d_vk_info *vk_info;
    VkImageViewCreateInfo view_desc;
    VkResult vr;
 
    vk_info = context_vk->vk_info;
 
    buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
    buffer_create_info.pNext = NULL;
    buffer_create_info.flags = 0;
    buffer_create_info.buffer = r->bo.vk_buffer;
    buffer_create_info.format = VK_FORMAT_R32_UINT;
    buffer_create_info.offset = r->bo.b.buffer_offset;
    buffer_create_info.range = r->bo.size;
 
    if ((vr = VK_CALL(vkCreateBufferView(device_vk->vk_device,
            &buffer_create_info, NULL, &v->vk_view_buffer_uint))) < 0)
    {
        ERR("Failed to create buffer view, vr %s.\n", wined3d_debug_vkresult(vr));
        return false;
    }
    TRACE("Created buffer view 0x%s.\n", wine_dbgstr_longlong(v->vk_view_buffer_uint));
 
    buffer_create_info.format = VK_FORMAT_R32G32B32A32_SFLOAT;
    if ((vr = VK_CALL(vkCreateBufferView(device_vk->vk_device,
            &buffer_create_info, NULL, &v->vk_view_buffer_float))) < 0)
    {
        ERR("Failed to create buffer view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    TRACE("Created buffer view 0x%s.\n", wine_dbgstr_longlong(v->vk_view_buffer_float));
 
    view_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    view_desc.pNext = NULL;
    view_desc.flags = 0;
    view_desc.image = r->image_1d.vk_image;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_1D;
    view_desc.format = VK_FORMAT_R8G8B8A8_UNORM;
    view_desc.components.r = VK_COMPONENT_SWIZZLE_ZERO;
    view_desc.components.g = VK_COMPONENT_SWIZZLE_ZERO;
    view_desc.components.b = VK_COMPONENT_SWIZZLE_ZERO;
    view_desc.components.a = VK_COMPONENT_SWIZZLE_ZERO;
    view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    view_desc.subresourceRange.baseMipLevel = 0;
    view_desc.subresourceRange.levelCount = 1;
    view_desc.subresourceRange.baseArrayLayer = 0;
    view_desc.subresourceRange.layerCount = 1;
 
    if (vk_info->supported[WINED3D_VK_KHR_MAINTENANCE2] || vk_info->api_version >= VK_API_VERSION_1_1)
    {
        usage_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR;
        usage_desc.pNext = NULL;
        usage_desc.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
 
        view_desc.pNext = &usage_desc;
    }
 
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_1d.imageView))) < 0)
    {
        ERR("Failed to create 1D image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_1d.sampler = VK_NULL_HANDLE;
    v->vk_info_1d.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 1D image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_1d.imageView));
 
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_1d_array.imageView))) < 0)
    {
        ERR("Failed to create 1D image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_1d_array.sampler = VK_NULL_HANDLE;
    v->vk_info_1d_array.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 1D array image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_1d_array.imageView));
 
    view_desc.image = r->image_2d.vk_image;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_2D;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_2d.imageView))) < 0)
    {
        ERR("Failed to create 2D image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_2d.sampler = VK_NULL_HANDLE;
    v->vk_info_2d.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 2D image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_2d.imageView));
 
    view_desc.image = r->image_2dms.vk_image;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_2D;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_2dms.imageView))) < 0)
    {
        ERR("Failed to create 2D MSAA image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_2dms.sampler = VK_NULL_HANDLE;
    v->vk_info_2dms.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 2D MSAA image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_2dms.imageView));
 
    view_desc.image = r->image_3d.vk_image;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_3D;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_3d.imageView))) < 0)
    {
        ERR("Failed to create 3D image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_3d.sampler = VK_NULL_HANDLE;
    v->vk_info_3d.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 3D image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_3d.imageView));
 
    view_desc.image = r->image_2d.vk_image;
    view_desc.subresourceRange.layerCount = 6;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_cube.imageView))) < 0)
    {
        ERR("Failed to create cube image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_cube.sampler = VK_NULL_HANDLE;
    v->vk_info_cube.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created cube image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_cube.imageView));
 
    view_desc.subresourceRange.layerCount = 1;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_2d_array.imageView))) < 0)
    {
        ERR("Failed to create 2D array image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_2d_array.sampler = VK_NULL_HANDLE;
    v->vk_info_2d_array.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 2D array image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_2d_array.imageView));
 
    view_desc.image = r->image_2dms.vk_image;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_2dms_array.imageView))) < 0)
    {
        ERR("Failed to create 2D MSAA array image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_2dms_array.sampler = VK_NULL_HANDLE;
    v->vk_info_2dms_array.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created 2D MSAA array image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_2dms_array.imageView));
 
    view_desc.image = r->image_2d.vk_image;
    view_desc.subresourceRange.layerCount = 6;
    view_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &view_desc, NULL, &v->vk_info_cube_array.imageView))) < 0)
    {
        ERR("Failed to create cube array image view, vr %s.\n", wined3d_debug_vkresult(vr));
        goto fail;
    }
    v->vk_info_cube_array.sampler = VK_NULL_HANDLE;
    v->vk_info_cube_array.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    TRACE("Created cube array image view 0x%s.\n", wine_dbgstr_longlong(v->vk_info_cube_array.imageView));
 
    return true;
 
fail:
    if (v->vk_info_cube_array.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_cube_array.imageView, NULL));
    if (v->vk_info_2d_array.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_2d_array.imageView, NULL));
    if (v->vk_info_cube.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_cube.imageView, NULL));
    if (v->vk_info_3d.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_3d.imageView, NULL));
    if (v->vk_info_2dms.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_2dms.imageView, NULL));
    if (v->vk_info_2d.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_2d.imageView, NULL));
    if (v->vk_info_1d_array.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_1d_array.imageView, NULL));
    if (v->vk_info_1d.imageView)
        VK_CALL(vkDestroyImageView(device_vk->vk_device, v->vk_info_1d.imageView, NULL));
    if (v->vk_view_buffer_float)
        VK_CALL(vkDestroyBufferView(device_vk->vk_device, v->vk_view_buffer_float, NULL));
    VK_CALL(vkDestroyBufferView(device_vk->vk_device, v->vk_view_buffer_uint, NULL));
    return false;
}

Referenced by adapter_vk_init_3d().

wined3d_device_vk_destroy_null_resources()

void wined3d_device_vk_destroy_null_resources	(	struct wined3d_device_vk *	device_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 910 of file device.c.

{
    struct wined3d_null_resources_vk *r = &device_vk->null_resources_vk;
 
    /* We don't track command buffer references to NULL resources. We easily
     * could, but it doesn't seem worth it. */
    wined3d_context_vk_reference_image(context_vk, &r->image_3d);
    wined3d_context_vk_destroy_image(context_vk, &r->image_3d);
    wined3d_context_vk_reference_image(context_vk, &r->image_2dms);
    wined3d_context_vk_destroy_image(context_vk, &r->image_2dms);
    wined3d_context_vk_reference_image(context_vk, &r->image_2d);
    wined3d_context_vk_destroy_image(context_vk, &r->image_2d);
    wined3d_context_vk_reference_image(context_vk, &r->image_1d);
    wined3d_context_vk_destroy_image(context_vk, &r->image_1d);
    wined3d_context_vk_reference_bo(context_vk, &r->bo);
    wined3d_context_vk_destroy_bo(context_vk, &r->bo);
}

Referenced by adapter_vk_uninit_3d_cs().

wined3d_device_vk_destroy_null_views()

void wined3d_device_vk_destroy_null_views	(	struct wined3d_device_vk *	device_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1114 of file device.c.

{
    struct wined3d_null_views_vk *v = &device_vk->null_views_vk;
    uint64_t id = context_vk->current_command_buffer.id;
 
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_cube_array.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_2dms_array.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_2d_array.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_cube.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_3d.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_2dms.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_2d.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_1d_array.imageView, id);
    wined3d_context_vk_destroy_vk_image_view(context_vk, v->vk_info_1d.imageView, id);
 
    wined3d_context_vk_destroy_vk_buffer_view(context_vk, v->vk_view_buffer_float, id);
    wined3d_context_vk_destroy_vk_buffer_view(context_vk, v->vk_view_buffer_uint, id);
}

Referenced by adapter_vk_uninit_3d_cs().

wined3d_device_vk_from_allocator()

static struct wined3d_device_vk * wined3d_device_vk_from_allocator ( struct wined3d_allocator *  allocator )

inlinestatic

Definition at line 846 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(allocator, struct wined3d_device_vk, allocator);
}

Referenced by wined3d_allocator_chunk_vk_lock(), wined3d_allocator_chunk_vk_unlock(), and wined3d_allocator_vk_destroy_chunk().

wined3d_device_vk_uav_clear_state_cleanup()

void wined3d_device_vk_uav_clear_state_cleanup

(

struct wined3d_device_vk *

device_vk

)

Definition at line 2057 of file view.c.

{
    struct wined3d_uav_clear_state_vk *state = &device_vk->uav_clear_state;
    const struct wined3d_vk_info *vk_info = &device_vk->vk_info;
 
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.buffer, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_1d, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_1d_array, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_2d, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_2d_array, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->float_pipelines.image_3d, NULL));
 
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.buffer, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_1d, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_1d_array, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_2d, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_2d_array, NULL));
    VK_CALL(vkDestroyPipeline(device_vk->vk_device, state->uint_pipelines.image_3d, NULL));
}

Referenced by adapter_vk_uninit_3d_cs().

wined3d_device_vk_uav_clear_state_init()

void wined3d_device_vk_uav_clear_state_init

(

struct wined3d_device_vk *

device_vk

)

Definition at line 1989 of file view.c.

{
    struct wined3d_uav_clear_state_vk *state = &device_vk->uav_clear_state;
    struct wined3d_context_vk *context_vk = &device_vk->context_vk;
    VkDescriptorSetLayoutBinding vk_set_bindings[2];
 
    vk_set_bindings[0].binding = 0;
    vk_set_bindings[0].descriptorCount = 1;
    vk_set_bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
    vk_set_bindings[0].pImmutableSamplers = NULL;
    vk_set_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
 
    vk_set_bindings[1].binding = 1;
    vk_set_bindings[1].descriptorCount = 1;
    vk_set_bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
    vk_set_bindings[1].pImmutableSamplers = NULL;
 
    vk_set_bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
    state->image_layout = wined3d_context_vk_get_pipeline_layout(context_vk, vk_set_bindings, 2);
 
    vk_set_bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
    state->buffer_layout = wined3d_context_vk_get_pipeline_layout(context_vk, vk_set_bindings, 2);
 
    state->float_pipelines.buffer = create_uav_pipeline(context_vk, state->buffer_layout,
            "cs_uav_clear_buffer_float_code.hlsl", WINED3D_SHADER_RESOURCE_BUFFER);
    state->uint_pipelines.buffer = create_uav_pipeline(context_vk, state->buffer_layout,
            "cs_uav_clear_buffer_uint_code.hlsl", WINED3D_SHADER_RESOURCE_BUFFER);
    state->float_pipelines.image_1d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_1d_float_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_1D);
    state->uint_pipelines.image_1d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_1d_uint_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_1D);
    state->float_pipelines.image_1d_array = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_1d_array_float_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY);
    state->uint_pipelines.image_1d_array = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_1d_array_uint_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_1DARRAY);
    state->float_pipelines.image_2d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_2d_float_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_2D);
    state->uint_pipelines.image_2d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_2d_uint_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_2D);
    state->float_pipelines.image_2d_array = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_2d_array_float_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY);
    state->uint_pipelines.image_2d_array = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_2d_array_uint_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_2DARRAY);
    state->float_pipelines.image_3d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_3d_float_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_3D);
    state->uint_pipelines.image_3d = create_uav_pipeline(context_vk, state->image_layout,
            "cs_uav_clear_3d_uint_code.hlsl", WINED3D_SHADER_RESOURCE_TEXTURE_3D);
 
    state->buffer_group_size.x = 128;
    state->buffer_group_size.y = 1;
    state->buffer_group_size.z = 1;
    state->image_1d_group_size.x = 64;
    state->image_1d_group_size.y = 1;
    state->image_1d_group_size.z = 1;
    state->image_1d_array_group_size.x = 64;
    state->image_1d_array_group_size.y = 1;
    state->image_1d_array_group_size.z = 1;
    state->image_2d_group_size.x = 8;
    state->image_2d_group_size.y = 8;
    state->image_2d_group_size.z = 1;
    state->image_2d_array_group_size.x = 8;
    state->image_2d_array_group_size.y = 8;
    state->image_2d_array_group_size.z = 1;
    state->image_3d_group_size.x = 8;
    state->image_3d_group_size.y = 8;
    state->image_3d_group_size.z = 1;
}

Referenced by adapter_vk_init_3d().

wined3d_format_colour_to_vk()

void wined3d_format_colour_to_vk	(	const struct wined3d_format *	format,
		const struct wined3d_color *	c,
		VkClearColorValue *	retval
	)

Definition at line 5790 of file utils.c.

{
    if (format->attrs & WINED3D_FORMAT_ATTR_INTEGER)
    {
        retval->int32[0] = c->r;
        retval->int32[1] = c->g;
        retval->int32[2] = c->b;
        retval->int32[3] = c->a;
    }
    else
    {
        retval->float32[0] = c->r;
        retval->float32[1] = c->g;
        retval->float32[2] = c->b;
        retval->float32[3] = c->a;
    }
}

Referenced by vk_blitter_clear_rendertargets(), wined3d_context_vk_begin_render_pass(), and wined3d_texture_vk_clear().

wined3d_format_vk()

static const struct wined3d_format_vk * wined3d_format_vk ( const struct wined3d_format *  format )

inlinestatic

Definition at line 1086 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(format, struct wined3d_format_vk, f);
}

wined3d_query_pool_vk_allocate_query()

bool wined3d_query_pool_vk_allocate_query	(	struct wined3d_query_pool_vk *	pool_vk,
		size_t *	idx
	)

Definition at line 1357 of file query.c.

{
    if ((*idx = wined3d_bitmap_ffz(pool_vk->allocated, WINED3D_QUERY_POOL_SIZE, 0)) > WINED3D_QUERY_POOL_SIZE)
        return false;
    wined3d_bitmap_set(pool_vk->allocated, *idx);
 
    return true;
}

Referenced by wined3d_context_vk_allocate_query().

wined3d_query_pool_vk_cleanup()

void wined3d_query_pool_vk_cleanup	(	struct wined3d_query_pool_vk *	pool_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1378 of file query.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
 
    VK_CALL(vkDestroyQueryPool(device_vk->vk_device, pool_vk->vk_query_pool, NULL));
    if (pool_vk->vk_event)
        VK_CALL(vkDestroyEvent(device_vk->vk_device, pool_vk->vk_event, NULL));
    list_remove(&pool_vk->entry);
    list_remove(&pool_vk->completed_entry);
}

Referenced by wined3d_context_vk_allocate_query(), and wined3d_context_vk_destroy_query_pools().

wined3d_query_pool_vk_init()

bool wined3d_query_pool_vk_init	(	struct wined3d_query_pool_vk *	pool_vk,
		struct wined3d_context_vk *	context_vk,
		enum wined3d_query_type	type,
		struct list *	free_pools
	)

Definition at line 1390 of file query.c.

{
    struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device);
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkQueryPoolCreateInfo pool_info;
    VkResult vr;
 
    list_init(&pool_vk->entry);
    list_init(&pool_vk->completed_entry);
    pool_vk->free_list = free_pools;
 
    pool_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
    pool_info.pNext = NULL;
    pool_info.flags = 0;
    pool_info.queryCount = WINED3D_QUERY_POOL_SIZE;
 
    switch (type)
    {
        case WINED3D_QUERY_TYPE_OCCLUSION:
            pool_info.queryType = VK_QUERY_TYPE_OCCLUSION;
            pool_info.pipelineStatistics = 0;
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP:
            pool_info.queryType = VK_QUERY_TYPE_TIMESTAMP;
            pool_info.pipelineStatistics = 0;
            break;
 
        case WINED3D_QUERY_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 WINED3D_QUERY_TYPE_SO_STATISTICS:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
            pool_info.queryType = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT;
            pool_info.pipelineStatistics = 0;
            break;
 
        default:
            FIXME("Unhandled query type %#x.\n", type);
            return false;
    }
 
    if ((vr = VK_CALL(vkCreateQueryPool(device_vk->vk_device, &pool_info, NULL, &pool_vk->vk_query_pool))) < 0)
    {
        ERR("Failed to create Vulkan query pool, vr %s.\n", wined3d_debug_vkresult(vr));
        return false;
    }
 
    list_add_head(free_pools, &pool_vk->entry);
 
    return true;
}

Referenced by wined3d_context_vk_allocate_query().

wined3d_query_pool_vk_mark_free()

void wined3d_query_pool_vk_mark_free	(	struct wined3d_context_vk *	context_vk,
		struct wined3d_query_pool_vk *	pool_vk,
		uint32_t	start,
		uint32_t	count
	)

Definition at line 1366 of file query.c.

{
    unsigned int idx, end = start + count;
 
    for (idx = start; idx < end; ++idx)
        wined3d_bitmap_clear(pool_vk->allocated, idx);
 
    if (list_empty(&pool_vk->entry))
        list_add_tail(pool_vk->free_list, &pool_vk->entry);
}

Referenced by wined3d_context_vk_cleanup_resources(), and wined3d_context_vk_reset_completed_queries().

wined3d_query_vk()

static struct wined3d_query_vk * wined3d_query_vk ( struct wined3d_query *  query )

inlinestatic

Definition at line 407 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(query, struct wined3d_query_vk, q);
}

wined3d_query_vk_accumulate_data()

bool wined3d_query_vk_accumulate_data	(	struct wined3d_query_vk *	query_vk,
		struct wined3d_device_vk *	device_vk,
		const struct wined3d_query_pool_idx_vk *	pool_idx
	)

Definition at line 1459 of file query.c.

{
    const struct wined3d_query_data_pipeline_statistics *ps_tmp;
    const struct wined3d_vk_info *vk_info = &device_vk->vk_info;
    struct wined3d_query_data_pipeline_statistics *ps_result;
    VkResult vr;
    union
    {
        uint64_t occlusion;
        uint64_t timestamp;
        struct wined3d_query_data_pipeline_statistics pipeline_statistics;
        struct wined3d_query_data_so_statistics so_statistics;
    } tmp, *result;
 
    if (pool_idx->pool_vk->vk_event)
    {
        /* Check if the pool's initial reset command executed. */
        vr = VK_CALL(vkGetEventStatus(device_vk->vk_device,
                pool_idx->pool_vk->vk_event));
        if (vr == VK_EVENT_RESET)
            return false;
        else if (vr != VK_EVENT_SET)
        {
            ERR("Failed to get event status, vr %s\n", wined3d_debug_vkresult(vr));
            return false;
        }
    }
 
    if ((vr = VK_CALL(vkGetQueryPoolResults(device_vk->vk_device, pool_idx->pool_vk->vk_query_pool,
            pool_idx->idx, 1, sizeof(tmp), &tmp, sizeof(tmp), VK_QUERY_RESULT_64_BIT))) < 0)
    {
        ERR("Failed to get query results, vr %s.\n", wined3d_debug_vkresult(vr));
        return false;
    }
 
    if (vr == VK_NOT_READY)
        return false;
 
    result = (void *)query_vk->q.data;
    switch (query_vk->q.type)
    {
        case WINED3D_QUERY_TYPE_OCCLUSION:
            result->occlusion += tmp.occlusion;
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP:
            result->timestamp = tmp.timestamp;
            break;
 
        case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
            ps_result = &result->pipeline_statistics;
            ps_tmp = &tmp.pipeline_statistics;
            ps_result->vertices_submitted += ps_tmp->vertices_submitted;
            ps_result->primitives_submitted += ps_tmp->primitives_submitted;
            ps_result->vs_invocations += ps_tmp->vs_invocations;
            ps_result->gs_invocations += ps_tmp->gs_invocations;
            ps_result->gs_primitives += ps_tmp->gs_primitives;
            ps_result->clipping_input_primitives += ps_tmp->clipping_input_primitives;
            ps_result->clipping_output_primitives += ps_tmp->clipping_output_primitives;
            ps_result->ps_invocations += ps_tmp->ps_invocations;
            ps_result->hs_invocations += ps_tmp->hs_invocations;
            ps_result->ds_invocations += ps_tmp->ds_invocations;
            ps_result->cs_invocations += ps_tmp->cs_invocations;
            break;
 
        case WINED3D_QUERY_TYPE_SO_STATISTICS:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
            result->so_statistics.primitives_written += tmp.so_statistics.primitives_written;
            result->so_statistics.primitives_generated += tmp.so_statistics.primitives_generated;
            break;
 
        default:
            FIXME("Unhandled query type %#x.\n", query_vk->q.type);
            return false;
    }
 
    return true;
}

Referenced by wined3d_query_vk_poll().

wined3d_query_vk_create()

HRESULT wined3d_query_vk_create	(	struct wined3d_device *	device,
		enum wined3d_query_type	type,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops,
		struct wined3d_query **	query
	)

Definition at line 1894 of file query.c.

{
    struct wined3d_query_data_timestamp_disjoint *disjoint_data;
    const struct wined3d_query_ops *ops = &wined3d_query_vk_ops;
    struct wined3d_query_vk *query_vk;
    unsigned int data_size;
    void *data;
 
    TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
            device, type, parent, parent_ops, query);
 
    switch (type)
    {
        case WINED3D_QUERY_TYPE_EVENT:
            ops = &wined3d_query_event_vk_ops;
            data_size = sizeof(BOOL);
            break;
 
        case WINED3D_QUERY_TYPE_OCCLUSION:
            data_size = sizeof(uint64_t);
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP:
            if (!wined3d_device_vk(device)->timestamp_bits)
            {
                WARN("Timestamp queries not supported.\n");
                return WINED3DERR_NOTAVAILABLE;
            }
            ops = &wined3d_query_timestamp_vk_ops;
            data_size = sizeof(uint64_t);
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
            if (!wined3d_device_vk(device)->timestamp_bits)
            {
                WARN("Timestamp queries not supported.\n");
                return WINED3DERR_NOTAVAILABLE;
            }
            ops = &wined3d_query_timestamp_disjoint_vk_ops;
            data_size = sizeof(struct wined3d_query_data_timestamp_disjoint);
            break;
 
        case WINED3D_QUERY_TYPE_PIPELINE_STATISTICS:
            data_size = sizeof(struct wined3d_query_data_pipeline_statistics);
            break;
 
        case WINED3D_QUERY_TYPE_SO_STATISTICS:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM0:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM1:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM2:
        case WINED3D_QUERY_TYPE_SO_STATISTICS_STREAM3:
            if (!wined3d_adapter_vk(device->adapter)->vk_info.supported[WINED3D_VK_EXT_TRANSFORM_FEEDBACK])
            {
                WARN("Stream output queries not supported.\n");
                return WINED3DERR_NOTAVAILABLE;
            }
            data_size = sizeof(struct wined3d_query_data_so_statistics);
            break;
 
        default:
            FIXME("Unhandled query type %#x.\n", type);
            return WINED3DERR_NOTAVAILABLE;
    }
 
    if (!(query_vk = calloc(1, sizeof(*query_vk) + data_size)))
        return E_OUTOFMEMORY;
    data = query_vk + 1;
 
    wined3d_query_init(&query_vk->q, device, type, data, data_size, ops, parent, parent_ops);
    query_vk->q.poll_in_cs = false;
 
    switch (type)
    {
        case WINED3D_QUERY_TYPE_OCCLUSION:
            query_vk->control_flags = VK_QUERY_CONTROL_PRECISE_BIT;
            break;
 
        case WINED3D_QUERY_TYPE_TIMESTAMP_DISJOINT:
            disjoint_data = data;
            disjoint_data->frequency = 1000000000 / wined3d_adapter_vk(device->adapter)->device_limits.timestampPeriod;
            disjoint_data->disjoint = FALSE;
            break;
 
        default:
            break;
    }
 
    TRACE("Created query %p.\n", query_vk);
    *query = &query_vk->q;
 
    return WINED3D_OK;
}

Referenced by adapter_vk_create_query().

wined3d_query_vk_resume()

void wined3d_query_vk_resume	(	struct wined3d_query_vk *	query_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1579 of file query.c.

{
    VkCommandBuffer vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
 
    wined3d_query_vk_begin(query_vk, context_vk, vk_command_buffer);
    query_vk->flags |= WINED3D_QUERY_VK_FLAG_ACTIVE;
}

Referenced by wined3d_context_vk_begin_render_pass(), and wined3d_context_vk_get_command_buffer().

wined3d_query_vk_suspend()

void wined3d_query_vk_suspend	(	struct wined3d_query_vk *	query_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1587 of file query.c.

{
    VkCommandBuffer vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer;
 
    wined3d_query_vk_end(query_vk, context_vk, vk_command_buffer);
 
    if (!wined3d_array_reserve((void **)&query_vk->pending, &query_vk->pending_size,
            query_vk->pending_count + 1, sizeof(*query_vk->pending)))
    {
        ERR("Failed to allocate entry.\n");
        return;
    }
 
    query_vk->pending[query_vk->pending_count++] = query_vk->pool_idx;
    query_vk->pool_idx.pool_vk = NULL;
    query_vk->flags &= ~WINED3D_QUERY_VK_FLAG_ACTIVE;
}

Referenced by wined3d_context_vk_end_current_render_pass(), and wined3d_context_vk_submit_command_buffer().

wined3d_rendertarget_view_vk()

static struct wined3d_rendertarget_view_vk * wined3d_rendertarget_view_vk ( struct wined3d_rendertarget_view *  view )

inlinestatic

Definition at line 955 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(view, struct wined3d_rendertarget_view_vk, v);
}

wined3d_rendertarget_view_vk_barrier()

static void wined3d_rendertarget_view_vk_barrier ( struct wined3d_rendertarget_view_vk *  rtv_vk, struct wined3d_context_vk *  context_vk, uint32_t  bind_mask  )

inlinestatic

Definition at line 961 of file wined3d_vk.h.

{
    wined3d_resource_vk_barrier(rtv_vk->v.resource, context_vk, bind_mask);
}

Referenced by vk_blitter_clear_rendertargets(), and wined3d_context_vk_begin_render_pass().

wined3d_rendertarget_view_vk_get_image_view()

static VkImageView wined3d_rendertarget_view_vk_get_image_view ( struct wined3d_rendertarget_view_vk *  rtv_vk, struct wined3d_context_vk *  context_vk  )

inlinestatic

Definition at line 967 of file wined3d_vk.h.

{
    struct wined3d_texture_vk *texture_vk;
 
    if (rtv_vk->vk_image_view)
        return rtv_vk->vk_image_view;
 
    texture_vk = wined3d_texture_vk(wined3d_texture_from_resource(rtv_vk->v.resource));
    return wined3d_texture_vk_get_default_image_info(texture_vk, context_vk)->imageView;
}

Referenced by vk_blitter_clear_rendertargets(), and wined3d_context_vk_begin_render_pass().

wined3d_rendertarget_view_vk_init()

HRESULT wined3d_rendertarget_view_vk_init	(	struct wined3d_rendertarget_view_vk *	view_vk,
		const struct wined3d_view_desc *	desc,
		struct wined3d_resource *	resource,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 916 of file view.c.

{
    HRESULT hr;
 
    TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
            view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
 
    if (FAILED(hr = wined3d_rendertarget_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
        return hr;
 
    wined3d_cs_init_object(resource->device->cs, wined3d_render_target_view_vk_cs_init, view_vk);
 
    return hr;
}

Referenced by adapter_vk_create_rendertarget_view().

wined3d_resource_vk_barrier()

static void wined3d_resource_vk_barrier ( struct wined3d_resource *  resource, struct wined3d_context_vk *  context_vk, uint32_t  bind_mask  )

inlinestatic

Definition at line 938 of file wined3d_vk.h.

{
    if (resource->type == WINED3D_RTYPE_BUFFER)
        wined3d_buffer_vk_barrier(wined3d_buffer_vk(buffer_from_resource(resource)), context_vk, bind_mask);
    else
        wined3d_texture_vk_barrier(wined3d_texture_vk(texture_from_resource(resource)), context_vk, bind_mask);
}

Referenced by wined3d_rendertarget_view_vk_barrier(), wined3d_shader_resource_view_vk_barrier(), and wined3d_unordered_access_view_vk_barrier().

wined3d_sampler_vk()

static struct wined3d_sampler_vk * wined3d_sampler_vk ( struct wined3d_sampler *  sampler )

inlinestatic

Definition at line 909 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(sampler, struct wined3d_sampler_vk, s);
}

wined3d_sampler_vk_init()

void wined3d_sampler_vk_init	(	struct wined3d_sampler_vk *	sampler_vk,
		struct wined3d_device *	device,
		const struct wined3d_sampler_desc *	desc,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 277 of file sampler.c.

{
    TRACE("sampler_vk %p, device %p, desc %p, parent %p, parent_ops %p.\n",
            sampler_vk, device, desc, parent, parent_ops);
 
    wined3d_sampler_init(&sampler_vk->s, device, desc, parent, parent_ops);
    wined3d_cs_init_object(device->cs, wined3d_sampler_vk_cs_init, sampler_vk);
}

Referenced by adapter_vk_create_sampler().

wined3d_shader_resource_view_vk()

static struct wined3d_shader_resource_view_vk * wined3d_shader_resource_view_vk ( struct wined3d_shader_resource_view *  view )

inlinestatic

Definition at line 1000 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(view, struct wined3d_shader_resource_view_vk, v);
}

wined3d_shader_resource_view_vk_barrier()

static void wined3d_shader_resource_view_vk_barrier ( struct wined3d_shader_resource_view_vk *  srv_vk, struct wined3d_context_vk *  context_vk, uint32_t  bind_mask  )

inlinestatic

Definition at line 1006 of file wined3d_vk.h.

{
    wined3d_resource_vk_barrier(srv_vk->v.resource, context_vk, bind_mask);
}

Referenced by wined3d_context_vk_load_shader_resources().

wined3d_shader_resource_view_vk_generate_mipmap()

void wined3d_shader_resource_view_vk_generate_mipmap	(	struct wined3d_shader_resource_view_vk *	srv_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1382 of file view.c.

{
    unsigned int i, j, layer_count, level_count, base_level, base_layer, sub_resource_idx;
    const struct wined3d_vk_info *vk_info = context_vk->vk_info;
    VkImageSubresourceRange vk_src_range, vk_dst_range;
    struct wined3d_texture_vk *texture_vk;
    VkCommandBuffer vk_command_buffer;
    VkImageBlit region;
 
    TRACE("srv_vk %p.\n", srv_vk);
 
    layer_count = srv_vk->v.desc.u.texture.layer_count;
    level_count = srv_vk->v.desc.u.texture.level_count;
    base_level = srv_vk->v.desc.u.texture.level_idx;
    base_layer = srv_vk->v.desc.u.texture.layer_idx;
 
    texture_vk = wined3d_texture_vk(texture_from_resource(srv_vk->v.resource));
    for (i = 0; i < layer_count; ++i)
    {
        sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level;
        if (!wined3d_texture_load_location(&texture_vk->t, sub_resource_idx,
                &context_vk->c, WINED3D_LOCATION_TEXTURE_RGB))
            ERR("Failed to load source layer %u.\n", base_layer + i);
    }
 
    if (context_vk->c.d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
        FIXME("Unhandled sRGB read/write control.\n");
 
    if (wined3d_format_vk(srv_vk->v.format)->vk_format != wined3d_format_vk(texture_vk->t.resource.format)->vk_format)
        FIXME("Ignoring view format %s.\n", debug_d3dformat(srv_vk->v.format->id));
 
    if (wined3d_resource_get_sample_count(&texture_vk->t.resource) > 1)
        FIXME("Unhandled multi-sampled resource.\n");
 
    if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
    {
        ERR("Failed to get command buffer.\n");
        return;
    }
 
    vk_src_range.aspectMask = vk_aspect_mask_from_format(texture_vk->t.resource.format);
    vk_src_range.baseMipLevel = base_level;
    vk_src_range.levelCount = 1;
    vk_src_range.baseArrayLayer = base_layer;
    vk_src_range.layerCount = layer_count;
 
    vk_dst_range = vk_src_range;
    ++vk_dst_range.baseMipLevel;
 
    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
            vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
            VK_ACCESS_TRANSFER_READ_BIT,
            texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
            texture_vk->image.vk_image, &vk_src_range);
    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
            vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
            VK_ACCESS_TRANSFER_WRITE_BIT,
            texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
            texture_vk->image.vk_image, &vk_dst_range);
 
    region.srcSubresource.aspectMask = vk_src_range.aspectMask;
    region.srcSubresource.mipLevel = vk_src_range.baseMipLevel;
    region.srcSubresource.baseArrayLayer = vk_src_range.baseArrayLayer;
    region.srcSubresource.layerCount = vk_src_range.layerCount;
    region.srcOffsets[0].x = 0;
    region.srcOffsets[0].y = 0;
    region.srcOffsets[0].z = 0;
 
    region.dstSubresource.aspectMask = vk_dst_range.aspectMask;
    region.dstSubresource.mipLevel = vk_dst_range.baseMipLevel;
    region.dstSubresource.baseArrayLayer = vk_dst_range.baseArrayLayer;
    region.dstSubresource.layerCount = vk_dst_range.layerCount;
    region.dstOffsets[0].x = 0;
    region.dstOffsets[0].y = 0;
    region.dstOffsets[0].z = 0;
 
    for (i = 1; i < level_count; ++i)
    {
        region.srcOffsets[1].x = wined3d_texture_get_level_width(&texture_vk->t, vk_src_range.baseMipLevel);
        region.srcOffsets[1].y = wined3d_texture_get_level_height(&texture_vk->t, vk_src_range.baseMipLevel);
        region.srcOffsets[1].z = wined3d_texture_get_level_depth(&texture_vk->t, vk_src_range.baseMipLevel);
 
        region.dstOffsets[1].x = wined3d_texture_get_level_width(&texture_vk->t, vk_dst_range.baseMipLevel);
        region.dstOffsets[1].y = wined3d_texture_get_level_height(&texture_vk->t, vk_dst_range.baseMipLevel);
        region.dstOffsets[1].z = wined3d_texture_get_level_depth(&texture_vk->t, vk_dst_range.baseMipLevel);
 
        VK_CALL(vkCmdBlitImage(vk_command_buffer, texture_vk->image.vk_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                texture_vk->image.vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region, VK_FILTER_LINEAR));
 
        wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
                VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                VK_ACCESS_TRANSFER_READ_BIT,
                vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, texture_vk->layout,
                texture_vk->image.vk_image, &vk_src_range);
 
        if (i == level_count - 1)
        {
            wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                    VK_ACCESS_TRANSFER_WRITE_BIT,
                    vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
                    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, texture_vk->layout,
                    texture_vk->image.vk_image, &vk_dst_range);
        }
        else
        {
            region.srcSubresource.mipLevel = ++vk_src_range.baseMipLevel;
            region.dstSubresource.mipLevel = ++vk_dst_range.baseMipLevel;
 
            wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
                    VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                    texture_vk->image.vk_image, &vk_src_range);
            wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
                    vk_access_mask_from_bind_flags(texture_vk->t.resource.bind_flags),
                    VK_ACCESS_TRANSFER_WRITE_BIT,
                    texture_vk->layout, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                    texture_vk->image.vk_image, &vk_dst_range);
        }
    }
 
    for (i = 0; i < layer_count; ++i)
    {
        for (j = 1; j < level_count; ++j)
        {
            sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level + j;
            wined3d_texture_validate_location(&texture_vk->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
            wined3d_texture_invalidate_location(&texture_vk->t, sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
        }
    }
 
    wined3d_context_vk_reference_texture(context_vk, texture_vk);
}

Referenced by adapter_vk_generate_mipmap().

wined3d_shader_resource_view_vk_init()

HRESULT wined3d_shader_resource_view_vk_init	(	struct wined3d_shader_resource_view_vk *	view_vk,
		const struct wined3d_view_desc *	desc,
		struct wined3d_resource *	resource,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 1243 of file view.c.

{
    HRESULT hr;
 
    TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
            view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
 
    if (FAILED(hr = wined3d_shader_resource_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
        return hr;
 
    list_init(&view_vk->view_vk.bo_user.entry);
    wined3d_cs_init_object(resource->device->cs, wined3d_shader_resource_view_vk_cs_init, view_vk);
 
    return hr;
}

Referenced by adapter_vk_create_shader_resource_view().

wined3d_shader_resource_view_vk_update_buffer()

void wined3d_shader_resource_view_vk_update_buffer	(	struct wined3d_shader_resource_view_vk *	view_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 1139 of file view.c.

{
    const struct wined3d_format_vk *view_format_vk = wined3d_format_vk(srv_vk->v.format);
    const struct wined3d_view_desc *desc = &srv_vk->v.desc;
    struct wined3d_resource *resource = srv_vk->v.resource;
    struct wined3d_view_vk *view_vk = &srv_vk->view_vk;
    struct wined3d_buffer_vk *buffer_vk;
    VkBufferView vk_buffer_view;
 
    assert(!view_vk->bo_user.valid);
 
    buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
    wined3d_context_vk_destroy_vk_buffer_view(context_vk, view_vk->u.vk_buffer_view, view_vk->command_buffer_id);
    if ((vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, desc, buffer_vk, view_format_vk)))
    {
        view_vk->u.vk_buffer_view = vk_buffer_view;
        view_vk->bo_user.valid = true;
        list_add_head(&buffer_vk->b.buffer_object->users, &view_vk->bo_user.entry);
    }
}

Referenced by wined3d_context_vk_load_shader_resources().

wined3d_shader_resource_view_vk_update_layout()

void wined3d_shader_resource_view_vk_update_layout	(	struct wined3d_shader_resource_view_vk *	srv_vk,
		VkImageLayout	layout
	)

Definition at line 1161 of file view.c.

{
    srv_vk->view_vk.u.vk_image_info.imageLayout = layout;
}

Referenced by wined3d_shader_descriptor_writes_vk_add_srv_write().

wined3d_swapchain_vk()

static struct wined3d_swapchain_vk * wined3d_swapchain_vk ( struct wined3d_swapchain *  swapchain )

inlinestatic

Definition at line 1068 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(swapchain, struct wined3d_swapchain_vk, s);
}

wined3d_swapchain_vk_cleanup()

void wined3d_swapchain_vk_cleanup

(

struct wined3d_swapchain_vk *

swapchain_vk

)

Definition at line 125 of file swapchain.c.

{
    struct wined3d_cs *cs = swapchain_vk->s.device->cs;
 
    wined3d_cs_destroy_object(cs, wined3d_swapchain_vk_destroy_object, swapchain_vk);
    wined3d_cs_finish(cs, WINED3D_CS_QUEUE_DEFAULT);
 
    wined3d_swapchain_cleanup(&swapchain_vk->s);
}

Referenced by adapter_vk_destroy_swapchain().

wined3d_swapchain_vk_init()

HRESULT wined3d_swapchain_vk_init	(	struct wined3d_swapchain_vk *	swapchain_vk,
		struct wined3d_device *	device,
		const struct wined3d_swapchain_desc *	desc,
		struct wined3d_swapchain_state_parent *	state_parent,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 1707 of file swapchain.c.

{
    HRESULT hr;
 
    TRACE("swapchain_vk %p, device %p, desc %p, parent %p, parent_ops %p.\n",
            swapchain_vk, device, desc, parent, parent_ops);
 
    if (FAILED(hr = wined3d_swapchain_init(&swapchain_vk->s, device, desc, state_parent, parent,
            parent_ops, &swapchain_vk_ops)))
        return hr;
 
    if (swapchain_vk->s.win_handle == GetDesktopWindow())
    {
        WARN("Creating a desktop window swapchain.\n");
        return hr;
    }
 
    if (FAILED(hr = wined3d_swapchain_vk_create_vulkan_swapchain(swapchain_vk)))
        WARN("Failed to create a Vulkan swapchain, hr %#lx.\n", hr);
 
    return WINED3D_OK;
}

Referenced by adapter_vk_create_swapchain().

wined3d_texture_vk()

static struct wined3d_texture_vk * wined3d_texture_vk ( struct wined3d_texture *  texture )

inlinestatic

Definition at line 884 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(texture, struct wined3d_texture_vk, t);
}

wined3d_texture_vk_barrier()

void wined3d_texture_vk_barrier	(	struct wined3d_texture_vk *	texture_vk,
		struct wined3d_context_vk *	context_vk,
		uint32_t	bind_mask
	)

Definition at line 5524 of file texture.c.

{
    enum VkImageLayout new_layout;
    uint32_t src_bind_mask = 0;
 
    TRACE("texture_vk %p, context_vk %p, bind_mask %s.\n",
            texture_vk, context_vk, wined3d_debug_bind_flags(bind_mask));
 
    new_layout = wined3d_layout_from_bind_mask(texture_vk, bind_mask);
 
    /* A layout transition is potentially a read-write operation, so even if we
     * prepare the texture to e.g. read only shader resource mode, we have to wait
     * for past operations to finish. */
    if (bind_mask & ~WINED3D_READ_ONLY_BIND_MASK || new_layout != texture_vk->layout)
    {
        src_bind_mask = texture_vk->bind_mask & WINED3D_READ_ONLY_BIND_MASK;
        if (!src_bind_mask)
            src_bind_mask = texture_vk->bind_mask;
 
        texture_vk->bind_mask = bind_mask;
    }
    else if ((texture_vk->bind_mask & bind_mask) != bind_mask)
    {
        src_bind_mask = texture_vk->bind_mask & ~WINED3D_READ_ONLY_BIND_MASK;
        texture_vk->bind_mask |= bind_mask;
    }
 
    if (src_bind_mask)
    {
        VkImageSubresourceRange vk_range;
 
        TRACE("    %s(%x) -> %s(%x).\n",
                wined3d_debug_bind_flags(src_bind_mask), texture_vk->layout,
                wined3d_debug_bind_flags(bind_mask), new_layout);
 
        vk_range.aspectMask = vk_aspect_mask_from_format(texture_vk->t.resource.format);
        vk_range.baseMipLevel = 0;
        vk_range.levelCount = VK_REMAINING_MIP_LEVELS;
        vk_range.baseArrayLayer = 0;
        vk_range.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
        wined3d_context_vk_image_barrier(context_vk, wined3d_context_vk_get_command_buffer(context_vk),
                vk_pipeline_stage_mask_from_bind_flags(src_bind_mask),
                vk_pipeline_stage_mask_from_bind_flags(bind_mask),
                vk_access_mask_from_bind_flags(src_bind_mask), vk_access_mask_from_bind_flags(bind_mask),
                texture_vk->layout, new_layout, texture_vk->image.vk_image, &vk_range);
 
        texture_vk->layout = new_layout;
    }
}

Referenced by wined3d_resource_vk_barrier().

wined3d_texture_vk_get_default_image_info()

const VkDescriptorImageInfo * wined3d_texture_vk_get_default_image_info	(	struct wined3d_texture_vk *	texture_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 4601 of file texture.c.

{
    const struct wined3d_format_vk *format_vk;
    const struct wined3d_vk_info *vk_info;
    struct wined3d_device_vk *device_vk;
    VkImageViewCreateInfo create_info;
    struct color_fixup_desc fixup;
    uint32_t flags = 0;
    VkResult vr;
 
    if (texture_vk->default_image_info.imageView)
        return &texture_vk->default_image_info;
 
    format_vk = wined3d_format_vk(texture_vk->t.resource.format);
    device_vk = wined3d_device_vk(texture_vk->t.resource.device);
    vk_info = context_vk->vk_info;
 
    if (texture_vk->t.layer_count > 1)
        flags |= WINED3D_VIEW_TEXTURE_ARRAY;
 
    wined3d_texture_vk_prepare_texture(texture_vk, context_vk);
    create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    create_info.pNext = NULL;
    create_info.flags = 0;
    create_info.image = texture_vk->image.vk_image;
    create_info.viewType = vk_image_view_type_from_wined3d(texture_vk->t.resource.type, flags);
    create_info.format = format_vk->vk_format;
    fixup = format_vk->f.color_fixup;
    if (is_identity_fixup(fixup) || !can_use_texture_swizzle(context_vk->c.d3d_info, &format_vk->f))
    {
        create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
        create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
        create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
        create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
    }
    else
    {
        wined3d_vk_swizzle_from_color_fixup(&create_info.components, fixup);
    }
    create_info.subresourceRange.aspectMask = vk_aspect_mask_from_format(&format_vk->f);
    create_info.subresourceRange.baseMipLevel = 0;
    create_info.subresourceRange.levelCount = texture_vk->t.level_count;
    create_info.subresourceRange.baseArrayLayer = 0;
    create_info.subresourceRange.layerCount = texture_vk->t.layer_count;
    if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &create_info,
            NULL, &texture_vk->default_image_info.imageView))) < 0)
    {
        ERR("Failed to create Vulkan image view, vr %s.\n", wined3d_debug_vkresult(vr));
        return NULL;
    }
 
    TRACE("Created image view 0x%s.\n", wine_dbgstr_longlong(texture_vk->default_image_info.imageView));
 
    texture_vk->default_image_info.sampler = VK_NULL_HANDLE;
 
    /* The default image view is used for SRVs, UAVs and RTVs when the d3d view encompasses the entire
     * resource. Any UAV capable resource will always use VK_IMAGE_LAYOUT_GENERAL, so we can use the
     * same image info for SRVs and UAVs. For render targets wined3d_rendertarget_view_vk_get_image_view
     * only cares about the VkImageView, not entire image info. So using SHADER_READ_ONLY_OPTIMAL works,
     * but relies on what the callers of the function do and don't do with the descriptor we return.
     *
     * Note that VkWriteDescriptorSet for SRV/UAV use takes a VkDescriptorImageInfo *, so we need a
     * place to store the VkDescriptorImageInfo. So returning onlky a VkImageView from this function
     * would bring its own problems. */
    if (texture_vk->layout == VK_IMAGE_LAYOUT_GENERAL)
        texture_vk->default_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
    else
        texture_vk->default_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
    return &texture_vk->default_image_info;
}

Referenced by wined3d_rendertarget_view_vk_get_image_view(), wined3d_shader_descriptor_writes_vk_add_srv_write(), wined3d_shader_descriptor_writes_vk_add_uav_write(), and wined3d_unordered_access_view_vk_clear().

wined3d_texture_vk_init()

HRESULT wined3d_texture_vk_init	(	struct wined3d_texture_vk *	texture_vk,
		struct wined3d_device *	device,
		const struct wined3d_resource_desc *	desc,
		unsigned int	layer_count,
		unsigned int	level_count,
		uint32_t	flags,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 5484 of file texture.c.

{
    TRACE("texture_vk %p, device %p, desc %p, layer_count %u, "
            "level_count %u, flags %#x, parent %p, parent_ops %p.\n",
            texture_vk, device, desc, layer_count,
            level_count, flags, parent, parent_ops);
 
    return wined3d_texture_init(&texture_vk->t, desc, layer_count, level_count,
            flags, device, parent, parent_ops, &texture_vk[1], &wined3d_texture_vk_ops);
}

Referenced by adapter_vk_create_texture().

wined3d_texture_vk_make_generic()

void wined3d_texture_vk_make_generic	(	struct wined3d_texture_vk *	texture_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 5581 of file texture.c.

{
    VkImageSubresourceRange vk_range;
 
    if (texture_vk->layout == VK_IMAGE_LAYOUT_GENERAL)
        return;
 
    vk_range.aspectMask = vk_aspect_mask_from_format(texture_vk->t.resource.format);
    vk_range.baseMipLevel = 0;
    vk_range.levelCount = VK_REMAINING_MIP_LEVELS;
    vk_range.baseArrayLayer = 0;
    vk_range.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
    wined3d_context_vk_image_barrier(context_vk, wined3d_context_vk_get_command_buffer(context_vk),
            VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
            VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
            0, 0,
            texture_vk->layout, VK_IMAGE_LAYOUT_GENERAL, texture_vk->image.vk_image, &vk_range);
 
    texture_vk->layout = VK_IMAGE_LAYOUT_GENERAL;
    texture_vk->default_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
}

Referenced by wined3d_context_vk_begin_render_pass().

wined3d_texture_vk_prepare_texture()

BOOL wined3d_texture_vk_prepare_texture	(	struct wined3d_texture_vk *	texture_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 5244 of file texture.c.

{
    const struct wined3d_format_vk *format_vk;
    struct wined3d_resource *resource;
    VkCommandBuffer vk_command_buffer;
    VkImageSubresourceRange vk_range;
    VkImageUsageFlags vk_usage;
    VkImageType vk_image_type;
    unsigned int flags = 0;
 
    if (texture_vk->t.flags & WINED3D_TEXTURE_RGB_ALLOCATED)
        return TRUE;
 
    if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
    {
        ERR("Failed to get command buffer.\n");
        return FALSE;
    }
 
    resource = &texture_vk->t.resource;
    format_vk = wined3d_format_vk(resource->format);
 
    if (wined3d_format_is_typeless(&format_vk->f) || texture_vk->t.swapchain
            || (texture_vk->t.resource.bind_flags & WINED3D_BIND_UNORDERED_ACCESS))
    {
        /* For UAVs, we need this in case a clear necessitates creation of a new view
         * with a different format. */
        flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
    }
 
    switch (resource->type)
    {
        case WINED3D_RTYPE_TEXTURE_1D:
            vk_image_type = VK_IMAGE_TYPE_1D;
            break;
        case WINED3D_RTYPE_TEXTURE_2D:
            vk_image_type = VK_IMAGE_TYPE_2D;
            if (texture_vk->t.layer_count >= 6 && resource->width == resource->height)
                flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
            break;
        case WINED3D_RTYPE_TEXTURE_3D:
            vk_image_type = VK_IMAGE_TYPE_3D;
            if (resource->bind_flags & (WINED3D_BIND_RENDER_TARGET | WINED3D_BIND_UNORDERED_ACCESS))
                flags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
            break;
        default:
            ERR("Invalid resource type %s.\n", debug_d3dresourcetype(resource->type));
            vk_image_type = VK_IMAGE_TYPE_2D;
            break;
    }
 
    vk_usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    if (resource->bind_flags & WINED3D_BIND_SHADER_RESOURCE)
        vk_usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
    if (resource->bind_flags & WINED3D_BIND_RENDER_TARGET)
        vk_usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
    if (resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        vk_usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
    if (resource->bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
        vk_usage |= VK_IMAGE_USAGE_STORAGE_BIT;
 
    if (resource->bind_flags & WINED3D_BIND_UNORDERED_ACCESS)
        texture_vk->layout = VK_IMAGE_LAYOUT_GENERAL;
    else if (resource->bind_flags & WINED3D_BIND_RENDER_TARGET)
        texture_vk->layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    else if (resource->bind_flags & WINED3D_BIND_DEPTH_STENCIL)
        texture_vk->layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    else if (resource->bind_flags & WINED3D_BIND_SHADER_RESOURCE)
        texture_vk->layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    else
    {
        FIXME("unexpected bind flags %s, using VK_IMAGE_LAYOUT_GENERAL\n", wined3d_debug_bind_flags(resource->bind_flags));
        texture_vk->layout = VK_IMAGE_LAYOUT_GENERAL;
    }
 
    if (!wined3d_context_vk_create_image(context_vk, vk_image_type, vk_usage, format_vk->vk_format,
            resource->width, resource->height, resource->depth, max(1, wined3d_resource_get_sample_count(resource)),
            texture_vk->t.level_count, texture_vk->t.layer_count, flags, &texture_vk->image))
    {
        return FALSE;
    }
 
    /* We can't use a zero src access mask without synchronization2. Set the last-used bind mask to something
     * non-zero to avoid this. */
    texture_vk->bind_mask = resource->bind_flags;
 
    vk_range.aspectMask = vk_aspect_mask_from_format(&format_vk->f);
    vk_range.baseMipLevel = 0;
    vk_range.levelCount = VK_REMAINING_MIP_LEVELS;
    vk_range.baseArrayLayer = 0;
    vk_range.layerCount = VK_REMAINING_ARRAY_LAYERS;
 
    wined3d_context_vk_reference_texture(context_vk, texture_vk);
    wined3d_context_vk_image_barrier(context_vk, vk_command_buffer,
            VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
            0, 0,
            VK_IMAGE_LAYOUT_UNDEFINED, texture_vk->layout,
            texture_vk->image.vk_image, &vk_range);
 
    texture_vk->t.flags |= WINED3D_TEXTURE_RGB_ALLOCATED;
 
    TRACE("Created image 0x%s, memory 0x%s for texture %p.\n",
            wine_dbgstr_longlong(texture_vk->image.vk_image), wine_dbgstr_longlong(texture_vk->image.vk_memory), texture_vk);
 
    return TRUE;
}

Referenced by wined3d_texture_vk_get_default_image_info(), wined3d_texture_vk_prepare_location(), and wined3d_view_vk_create_vk_image_view().

wined3d_unordered_access_view_vk()

static struct wined3d_unordered_access_view_vk * wined3d_unordered_access_view_vk ( struct wined3d_unordered_access_view *  view )

inlinestatic

Definition at line 1031 of file wined3d_vk.h.

{
    return CONTAINING_RECORD(view, struct wined3d_unordered_access_view_vk, v);
}

wined3d_unordered_access_view_vk_barrier()

static void wined3d_unordered_access_view_vk_barrier ( struct wined3d_unordered_access_view_vk *  uav_vk, struct wined3d_context_vk *  context_vk, uint32_t  bind_mask  )

inlinestatic

Definition at line 1037 of file wined3d_vk.h.

{
    wined3d_resource_vk_barrier(uav_vk->v.resource, context_vk, bind_mask);
}

Referenced by wined3d_context_vk_load_shader_resources().

wined3d_unordered_access_view_vk_clear()

void wined3d_unordered_access_view_vk_clear	(	struct wined3d_unordered_access_view_vk *	view_vk,
		const struct wined3d_uvec4 *	clear_value,
		struct wined3d_context_vk *	context_vk,
		bool	fp
	)

Definition at line 2077 of file view.c.

{
    struct wined3d_bo_address cb_source_address, cb_destination_address;
    const struct wined3d_format *view_format = view_vk->v.format;
    struct wined3d_view_desc *view_desc = &view_vk->v.desc;
    struct wined3d_uav_clear_constants_vk constants = {0};
    struct wined3d_device *device = context_vk->c.device;
    struct wined3d_shader_thread_group_size group_count;
    enum wined3d_format_id format_id = view_format->id;
    struct wined3d_uav_clear_pipelines_vk *pipelines;
    struct wined3d_texture_vk *texture_vk = NULL;
    struct wined3d_pipeline_layout_vk *layout;
    struct wined3d_uav_clear_state_vk *state;
    const struct wined3d_vk_info *vk_info;
    VkDescriptorImageInfo vk_image_info;
    struct wined3d_device_vk *device_vk;
    VkDescriptorBufferInfo buffer_info;
    struct wined3d_resource *resource;
    VkCommandBuffer vk_command_buffer;
    struct wined3d_bo_vk constants_bo;
    VkWriteDescriptorSet vk_writes[2];
    VkBufferView vk_buffer_view;
    struct wined3d_range range;
    VkMemoryBarrier vk_barrier;
    VkPipeline vk_pipeline;
    bool is_array;
 
    device_vk = wined3d_device_vk(device);
    state = &device_vk->uav_clear_state;
    pipelines = fp ? &state->float_pipelines : &state->uint_pipelines;
 
    resource = view_vk->v.resource;
    is_array = view_desc->flags & WINED3D_VIEW_TEXTURE_ARRAY;
 
    switch (resource->type)
    {
        case WINED3D_RTYPE_BUFFER:
            vk_pipeline = pipelines->buffer;
            group_count = state->buffer_group_size;
            break;
        case WINED3D_RTYPE_TEXTURE_1D:
            if (is_array)
            {
                vk_pipeline = pipelines->image_1d_array;
                group_count = state->image_1d_array_group_size;
            }
            else
            {
                vk_pipeline = pipelines->image_1d;
                group_count = state->image_1d_group_size;
            }
            break;
        case WINED3D_RTYPE_TEXTURE_2D:
            if (is_array)
            {
                vk_pipeline = pipelines->image_2d_array;
                group_count = state->image_2d_array_group_size;
            }
            else
            {
                vk_pipeline = pipelines->image_2d;
                group_count = state->image_2d_group_size;
            }
            break;
        case WINED3D_RTYPE_TEXTURE_3D:
            vk_pipeline = pipelines->image_3d;
            group_count = state->image_3d_group_size;
            break;
 
        default:
            ERR("Unhandled resource type %s.\n", debug_d3dresourcetype(resource->type));
            return;
    }
 
    if (vk_pipeline == VK_NULL_HANDLE)
    {
        ERR("Pipeline was not correctly initialized.\n");
        return;
    }
 
    vk_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
    vk_writes[0].pNext = NULL;
    vk_writes[0].dstBinding = 1;
    vk_writes[0].dstArrayElement = 0;
    vk_writes[0].descriptorCount = 1;
    vk_writes[0].pImageInfo = NULL;
    vk_writes[0].pTexelBufferView = &vk_buffer_view;
    vk_writes[0].pImageInfo = &vk_image_info;
 
    if (resource->type == WINED3D_RTYPE_BUFFER)
    {
        struct wined3d_buffer *buffer = buffer_from_resource(resource);
        unsigned int offset, size;
 
        layout = state->buffer_layout;
        vk_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
 
        if (buffer->structure_byte_stride)
            constants.extent.width = view_desc->u.buffer.count * buffer->structure_byte_stride / 4;
        else
            constants.extent.width = view_desc->u.buffer.count;
        constants.extent.height = 1;
 
        get_buffer_view_range(buffer, view_desc, view_format, &offset, &size);
        if (!offset && size == buffer->resource.size)
        {
            wined3d_buffer_prepare_location(buffer, &context_vk->c, WINED3D_LOCATION_BUFFER);
        }
        else
        {
            wined3d_buffer_acquire_bo_for_write(buffer, &context_vk->c);
            wined3d_buffer_load_location(buffer, &context_vk->c, WINED3D_LOCATION_BUFFER);
        }
        wined3d_buffer_validate_location(buffer, WINED3D_LOCATION_BUFFER);
        wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER);
    }
    else
    {
        unsigned int layer_count, level_count, base_level, base_layer, i, j;
 
        texture_vk = wined3d_texture_vk(wined3d_texture_from_resource(resource));
 
        layout = state->image_layout;
        vk_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
 
        level_count = view_desc->u.texture.level_count;
        base_level = view_desc->u.texture.level_idx;
        if (resource->type == WINED3D_RTYPE_TEXTURE_3D)
        {
            layer_count = 1;
            base_layer = 0;
        }
        else
        {
            layer_count = view_desc->u.texture.layer_count;
            base_layer = view_desc->u.texture.layer_idx;
        }
 
        constants.extent.width  = wined3d_texture_get_level_width(&texture_vk->t, base_level);
        constants.extent.height = wined3d_texture_get_level_height(&texture_vk->t, base_level);
        group_count.z = (view_desc->u.texture.layer_count + group_count.z - 1) / group_count.z;
 
        for (i = 0; i < layer_count; ++i)
        {
            for (j = 0; j < level_count; ++j)
            {
                unsigned int sub_resource_idx = (base_layer + i) * texture_vk->t.level_count + base_level + j;
 
                wined3d_texture_prepare_location(&texture_vk->t, sub_resource_idx,
                        &context_vk->c, WINED3D_LOCATION_TEXTURE_RGB);
                wined3d_texture_validate_location(&texture_vk->t, sub_resource_idx, WINED3D_LOCATION_TEXTURE_RGB);
                wined3d_texture_invalidate_location(&texture_vk->t, sub_resource_idx, ~WINED3D_LOCATION_TEXTURE_RGB);
            }
        }
    }
 
    group_count.x = (constants.extent.width  + group_count.x - 1) / group_count.x;
    group_count.y = (constants.extent.height + group_count.y - 1) / group_count.y;
 
    constants.color.uint32[0] = clear_value->x;
    constants.color.uint32[1] = clear_value->y;
    constants.color.uint32[2] = clear_value->z;
    constants.color.uint32[3] = clear_value->w;
 
    if (!fp)
    {
        /* Make sure values are truncated, not saturated to some maximum value. */
        constants.color.uint32[0] &= wined3d_mask_from_size(view_format->red_size);
        constants.color.uint32[1] &= wined3d_mask_from_size(view_format->green_size);
        constants.color.uint32[2] &= wined3d_mask_from_size(view_format->blue_size);
        constants.color.uint32[3] &= wined3d_mask_from_size(view_format->alpha_size);
 
        if (view_format->id == WINED3DFMT_R11G11B10_FLOAT)
        {
            constants.color.uint32[0] |= constants.color.uint32[1] << 11;
            constants.color.uint32[0] |= constants.color.uint32[2] << 22;
            format_id = WINED3DFMT_R32_UINT;
        }
        else
        {
            format_id = wined3d_get_typed_format_id(context_vk->c.device->adapter, view_format,
                    WINED3D_CHANNEL_TYPE_UINT);
        }
    }
 
    if (format_id == WINED3DFMT_UNKNOWN)
    {
        ERR("Unsupported format %s.\n", debug_d3dformat(view_format->id));
        return;
    }
 
    if (resource->type == WINED3D_RTYPE_BUFFER)
    {
        if (format_id == view_format->id)
            vk_buffer_view = view_vk->view_vk.u.vk_buffer_view;
        else
        {
            vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, view_desc,
                    wined3d_buffer_vk(buffer_from_resource(resource)), wined3d_format_vk(
                        wined3d_get_format(context_vk->c.device->adapter, format_id, WINED3D_BIND_UNORDERED_ACCESS)));
            if (vk_buffer_view == VK_NULL_HANDLE)
                return;
        }
    }
    else
    {
        if (format_id == view_format->id)
        {
            vk_image_info = view_vk->view_vk.u.vk_image_info;
            if (!vk_image_info.imageView)
            {
                const VkDescriptorImageInfo *default_info;
                if (!(default_info = wined3d_texture_vk_get_default_image_info(texture_vk, context_vk)))
                    return;
                vk_image_info = *default_info;
            }
        }
        else
        {
            vk_image_info.sampler = VK_NULL_HANDLE;
            vk_image_info.imageLayout = texture_vk->layout;
            vk_image_info.imageView = wined3d_view_vk_create_vk_image_view(context_vk, view_desc, texture_vk,
                    wined3d_format_vk(wined3d_get_format(context_vk->c.device->adapter, format_id,
                        WINED3D_BIND_UNORDERED_ACCESS)),
                    COLOR_FIXUP_IDENTITY, false, VK_IMAGE_USAGE_STORAGE_BIT);
 
            if (vk_image_info.imageView == VK_NULL_HANDLE)
                return;
        }
    }
 
    vk_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
    vk_writes[1].pNext = NULL;
    vk_writes[1].dstBinding = 0;
    vk_writes[1].dstArrayElement = 0;
    vk_writes[1].descriptorCount = 1;
    vk_writes[1].pImageInfo = NULL;
    vk_writes[1].pTexelBufferView = NULL;
    vk_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    vk_writes[1].pBufferInfo = &buffer_info;
 
    if (!wined3d_context_vk_create_bo(context_vk, sizeof(constants), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &constants_bo))
    {
        ERR("Failed to create constants BO.\n");
        goto out;
    }
 
    cb_source_address.buffer_object = NULL;
    cb_source_address.addr = (BYTE *)&constants;
    cb_destination_address.buffer_object = &constants_bo.b;
    cb_destination_address.addr = 0;
 
    range.offset = 0;
    range.size = sizeof(constants);
    adapter_vk_copy_bo_address(&context_vk->c, &cb_destination_address,
            &cb_source_address, 1, &range, WINED3D_MAP_WRITE | WINED3D_MAP_DISCARD);
 
    buffer_info.buffer = constants_bo.vk_buffer;
    buffer_info.range = constants_bo.size;
    buffer_info.offset = constants_bo.b.buffer_offset;
 
    vk_info = context_vk->vk_info;
 
    if (!(vk_writes[0].dstSet = wined3d_context_vk_create_vk_descriptor_set(context_vk, layout->vk_set_layout)))
    {
        ERR("Failed to create descriptor set.\n");
        wined3d_context_vk_destroy_bo(context_vk, &constants_bo);
        goto out;
    }
 
    vk_writes[1].dstSet = vk_writes[0].dstSet;
 
    VK_CALL(vkUpdateDescriptorSets(device_vk->vk_device, 2, vk_writes, 0, NULL));
 
    vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk);
    wined3d_context_vk_end_current_render_pass(context_vk);
 
    wined3d_context_vk_reference_unordered_access_view(context_vk, view_vk);
    wined3d_context_vk_reference_bo(context_vk, &constants_bo);
    wined3d_context_vk_destroy_bo(context_vk, &constants_bo);
 
    vk_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
    vk_barrier.pNext = NULL;
    vk_barrier.srcAccessMask = vk_access_mask_from_bind_flags(resource->bind_flags);
    vk_barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
 
    VK_CALL(vkCmdPipelineBarrier(vk_command_buffer,
            vk_pipeline_stage_mask_from_bind_flags(resource->bind_flags),
            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
            0, 1, &vk_barrier, 0, NULL, 0, NULL));
    VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline));
    VK_CALL(vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
            layout->vk_pipeline_layout, 0, 1, &vk_writes[0].dstSet, 0, NULL));
    VK_CALL(vkCmdDispatch(vk_command_buffer, group_count.x, group_count.y, group_count.z));
 
    vk_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
    vk_barrier.dstAccessMask = vk_access_mask_from_bind_flags(resource->bind_flags);
 
    VK_CALL(vkCmdPipelineBarrier(vk_command_buffer,
            VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
            vk_pipeline_stage_mask_from_bind_flags(resource->bind_flags),
            0, 1, &vk_barrier, 0, NULL, 0, NULL));
 
    context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_SHADER);
 
out:
    if (format_id != view_format->id)
    {
        if (resource->type == WINED3D_RTYPE_BUFFER)
            wined3d_context_vk_destroy_vk_buffer_view(context_vk, vk_buffer_view, view_vk->view_vk.command_buffer_id);
        else
            wined3d_context_vk_destroy_vk_image_view(context_vk, vk_image_info.imageView,
                    view_vk->view_vk.command_buffer_id);
    }
}

Referenced by adapter_vk_clear_uav().

wined3d_unordered_access_view_vk_init()

HRESULT wined3d_unordered_access_view_vk_init	(	struct wined3d_unordered_access_view_vk *	view_vk,
		const struct wined3d_view_desc *	desc,
		struct wined3d_resource *	resource,
		void *	parent,
		const struct wined3d_parent_ops *	parent_ops
	)

Definition at line 2533 of file view.c.

{
    HRESULT hr;
 
    TRACE("view_vk %p, desc %s, resource %p, parent %p, parent_ops %p.\n",
            view_vk, wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops);
 
    if (FAILED(hr = wined3d_unordered_access_view_init(&view_vk->v, desc, resource, parent, parent_ops)))
        return hr;
 
    list_init(&view_vk->view_vk.bo_user.entry);
    wined3d_cs_init_object(resource->device->cs, wined3d_unordered_access_view_vk_cs_init, view_vk);
 
    return hr;
}

Referenced by adapter_vk_create_unordered_access_view().

wined3d_unordered_access_view_vk_update()

void wined3d_unordered_access_view_vk_update	(	struct wined3d_unordered_access_view_vk *	view_vk,
		struct wined3d_context_vk *	context_vk
	)

Definition at line 2395 of file view.c.

{
    const struct wined3d_format_vk *view_format_vk = wined3d_format_vk(uav_vk->v.format);
    const struct wined3d_view_desc *desc = &uav_vk->v.desc;
    struct wined3d_resource *resource = uav_vk->v.resource;
    struct wined3d_view_vk *view_vk = &uav_vk->view_vk;
    struct wined3d_buffer_vk *buffer_vk;
    VkBufferView vk_buffer_view;
 
    assert(!view_vk->bo_user.valid);
 
    buffer_vk = wined3d_buffer_vk(buffer_from_resource(resource));
    wined3d_context_vk_destroy_vk_buffer_view(context_vk, view_vk->u.vk_buffer_view, view_vk->command_buffer_id);
    if ((vk_buffer_view = wined3d_view_vk_create_vk_buffer_view(context_vk, desc, buffer_vk, view_format_vk)))
    {
        view_vk->u.vk_buffer_view = vk_buffer_view;
        view_vk->bo_user.valid = true;
        list_add_head(&buffer_vk->b.buffer_object->users, &view_vk->bo_user.entry);
    }
}

Referenced by wined3d_context_vk_load_shader_resources().

wined3d_vk_swizzle_from_color_fixup()

void wined3d_vk_swizzle_from_color_fixup	(	VkComponentMapping *	mapping,
		struct color_fixup_desc	fixup
	)

Definition at line 4583 of file texture.c.

{
    static const VkComponentSwizzle swizzle_source[] =
    {
        VK_COMPONENT_SWIZZLE_ZERO,  /* CHANNEL_SOURCE_ZERO */
        VK_COMPONENT_SWIZZLE_ONE,   /* CHANNEL_SOURCE_ONE */
        VK_COMPONENT_SWIZZLE_R,     /* CHANNEL_SOURCE_X */
        VK_COMPONENT_SWIZZLE_G,     /* CHANNEL_SOURCE_Y */
        VK_COMPONENT_SWIZZLE_B,     /* CHANNEL_SOURCE_Z */
        VK_COMPONENT_SWIZZLE_A,     /* CHANNEL_SOURCE_W */
    };
 
    mapping->r = swizzle_source[fixup.x_source];
    mapping->g = swizzle_source[fixup.y_source];
    mapping->b = swizzle_source[fixup.z_source];
    mapping->a = swizzle_source[fixup.w_source];
}

Referenced by wined3d_texture_vk_get_default_image_info(), and wined3d_view_vk_create_vk_image_view().

Variable Documentation

WINED3D_READ_ONLY_ACCESS_FLAGS

const VkAccessFlags WINED3D_READ_ONLY_ACCESS_FLAGS

static

Initial value:

= VK_ACCESS_INDIRECT_COMMAND_READ_BIT
        | VK_ACCESS_INDEX_READ_BIT | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT
        | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
        | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_HOST_READ_BIT
        | VK_ACCESS_MEMORY_READ_BIT

Definition at line 274 of file wined3d_vk.h.