| /* |
| * Copyright © 2019 Red Hat. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| |
| #pragma once |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <stdbool.h> |
| #include <string.h> |
| #include <strings.h> |
| #include <pthread.h> |
| #include <assert.h> |
| #include <stdint.h> |
| |
| #include "util/macros.h" |
| #include "util/list.h" |
| |
| #include "compiler/shader_enums.h" |
| #include "pipe/p_screen.h" |
| #include "pipe/p_state.h" |
| #include "nir.h" |
| |
| /* Pre-declarations needed for WSI entrypoints */ |
| struct wl_surface; |
| struct wl_display; |
| typedef struct xcb_connection_t xcb_connection_t; |
| typedef uint32_t xcb_visualid_t; |
| typedef uint32_t xcb_window_t; |
| |
| #define VK_PROTOTYPES |
| #include <vulkan/vulkan.h> |
| #include <vulkan/vk_icd.h> |
| |
| #include "val_extensions.h" |
| #include "val_entrypoints.h" |
| #include "vk_object.h" |
| |
| #include "wsi_common.h" |
| |
| #include <assert.h> |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #define MAX_SETS 8 |
| #define MAX_PUSH_CONSTANTS_SIZE 128 |
| |
| #define val_printflike(a, b) __attribute__((__format__(__printf__, a, b))) |
| |
| #define typed_memcpy(dest, src, count) ({ \ |
| memcpy((dest), (src), (count) * sizeof(*(src))); \ |
| }) |
| |
| int val_get_instance_entrypoint_index(const char *name); |
| int val_get_device_entrypoint_index(const char *name); |
| int val_get_physical_device_entrypoint_index(const char *name); |
| |
| const char *val_get_instance_entry_name(int index); |
| const char *val_get_physical_device_entry_name(int index); |
| const char *val_get_device_entry_name(int index); |
| |
| bool val_instance_entrypoint_is_enabled(int index, uint32_t core_version, |
| const struct val_instance_extension_table *instance); |
| bool val_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, |
| const struct val_instance_extension_table *instance); |
| bool val_device_entrypoint_is_enabled(int index, uint32_t core_version, |
| const struct val_instance_extension_table *instance, |
| const struct val_device_extension_table *device); |
| |
| void *val_lookup_entrypoint(const char *name); |
| |
| #define VAL_DEFINE_HANDLE_CASTS(__val_type, __VkType) \ |
| \ |
| static inline struct __val_type * \ |
| __val_type ## _from_handle(__VkType _handle) \ |
| { \ |
| return (struct __val_type *) _handle; \ |
| } \ |
| \ |
| static inline __VkType \ |
| __val_type ## _to_handle(struct __val_type *_obj) \ |
| { \ |
| return (__VkType) _obj; \ |
| } |
| |
| #define VAL_DEFINE_NONDISP_HANDLE_CASTS(__val_type, __VkType) \ |
| \ |
| static inline struct __val_type * \ |
| __val_type ## _from_handle(__VkType _handle) \ |
| { \ |
| return (struct __val_type *)(uintptr_t) _handle; \ |
| } \ |
| \ |
| static inline __VkType \ |
| __val_type ## _to_handle(struct __val_type *_obj) \ |
| { \ |
| return (__VkType)(uintptr_t) _obj; \ |
| } |
| |
| #define VAL_FROM_HANDLE(__val_type, __name, __handle) \ |
| struct __val_type *__name = __val_type ## _from_handle(__handle) |
| |
| VAL_DEFINE_HANDLE_CASTS(val_cmd_buffer, VkCommandBuffer) |
| VAL_DEFINE_HANDLE_CASTS(val_device, VkDevice) |
| VAL_DEFINE_HANDLE_CASTS(val_instance, VkInstance) |
| VAL_DEFINE_HANDLE_CASTS(val_physical_device, VkPhysicalDevice) |
| VAL_DEFINE_HANDLE_CASTS(val_queue, VkQueue) |
| |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_cmd_pool, VkCommandPool) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_buffer, VkBuffer) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_buffer_view, VkBufferView) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_pool, VkDescriptorPool) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_set, VkDescriptorSet) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_set_layout, VkDescriptorSetLayout) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_device_memory, VkDeviceMemory) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_event, VkEvent) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_framebuffer, VkFramebuffer) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_image, VkImage) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_image_view, VkImageView); |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline_cache, VkPipelineCache) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline, VkPipeline) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline_layout, VkPipelineLayout) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_query_pool, VkQueryPool) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_render_pass, VkRenderPass) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_sampler, VkSampler) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_shader_module, VkShaderModule) |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_fence, VkFence); |
| VAL_DEFINE_NONDISP_HANDLE_CASTS(val_semaphore, VkSemaphore); |
| |
| /* Whenever we generate an error, pass it through this function. Useful for |
| * debugging, where we can break on it. Only call at error site, not when |
| * propagating errors. Might be useful to plug in a stack trace here. |
| */ |
| |
| VkResult __vk_errorf(struct val_instance *instance, VkResult error, const char *file, int line, const char *format, ...); |
| |
| #define VAL_DEBUG_ALL_ENTRYPOINTS (1 << 0) |
| |
| #define vk_error(instance, error) __vk_errorf(instance, error, __FILE__, __LINE__, NULL); |
| #define vk_errorf(instance, error, format, ...) __vk_errorf(instance, error, __FILE__, __LINE__, format, ## __VA_ARGS__); |
| |
| void __val_finishme(const char *file, int line, const char *format, ...) |
| val_printflike(3, 4); |
| |
| #define val_finishme(format, ...) \ |
| __val_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); |
| |
| #define stub_return(v) \ |
| do { \ |
| val_finishme("stub %s", __func__); \ |
| return (v); \ |
| } while (0) |
| |
| #define stub() \ |
| do { \ |
| val_finishme("stub %s", __func__); \ |
| return; \ |
| } while (0) |
| |
| struct val_shader_module { |
| struct vk_object_base base; |
| uint32_t size; |
| char data[0]; |
| }; |
| |
| static inline gl_shader_stage |
| vk_to_mesa_shader_stage(VkShaderStageFlagBits vk_stage) |
| { |
| assert(__builtin_popcount(vk_stage) == 1); |
| return ffs(vk_stage) - 1; |
| } |
| |
| static inline VkShaderStageFlagBits |
| mesa_to_vk_shader_stage(gl_shader_stage mesa_stage) |
| { |
| return (1 << mesa_stage); |
| } |
| |
| #define VAL_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1) |
| |
| #define val_foreach_stage(stage, stage_bits) \ |
| for (gl_shader_stage stage, \ |
| __tmp = (gl_shader_stage)((stage_bits) & VAL_STAGE_MASK); \ |
| stage = __builtin_ffs(__tmp) - 1, __tmp; \ |
| __tmp &= ~(1 << (stage))) |
| |
| struct val_physical_device { |
| VK_LOADER_DATA _loader_data; |
| struct val_instance * instance; |
| |
| struct pipe_loader_device *pld; |
| struct pipe_screen *pscreen; |
| uint32_t max_images; |
| |
| struct wsi_device wsi_device; |
| struct val_device_extension_table supported_extensions; |
| }; |
| |
| struct val_instance { |
| struct vk_object_base base; |
| |
| VkAllocationCallbacks alloc; |
| |
| uint32_t apiVersion; |
| int physicalDeviceCount; |
| struct val_physical_device physicalDevice; |
| |
| uint64_t debug_flags; |
| |
| struct pipe_loader_device *devs; |
| int num_devices; |
| |
| struct val_instance_extension_table enabled_extensions; |
| struct val_instance_dispatch_table dispatch; |
| struct val_physical_device_dispatch_table physical_device_dispatch; |
| struct val_device_dispatch_table device_dispatch; |
| }; |
| |
| VkResult val_init_wsi(struct val_physical_device *physical_device); |
| void val_finish_wsi(struct val_physical_device *physical_device); |
| |
| bool val_instance_extension_supported(const char *name); |
| uint32_t val_physical_device_api_version(struct val_physical_device *dev); |
| bool val_physical_device_extension_supported(struct val_physical_device *dev, |
| const char *name); |
| |
| struct val_queue { |
| VK_LOADER_DATA _loader_data; |
| VkDeviceQueueCreateFlags flags; |
| struct val_device * device; |
| struct pipe_context *ctx; |
| bool shutdown; |
| thrd_t exec_thread; |
| mtx_t m; |
| cnd_t new_work; |
| struct list_head workqueue; |
| uint32_t count; |
| }; |
| |
| struct val_queue_work { |
| struct list_head list; |
| uint32_t cmd_buffer_count; |
| struct val_cmd_buffer **cmd_buffers; |
| struct val_fence *fence; |
| }; |
| |
| struct val_pipeline_cache { |
| struct vk_object_base base; |
| struct val_device * device; |
| VkAllocationCallbacks alloc; |
| }; |
| |
| struct val_device { |
| struct vk_device vk; |
| |
| VkAllocationCallbacks alloc; |
| |
| struct val_queue queue; |
| struct val_instance * instance; |
| struct val_physical_device *physical_device; |
| struct pipe_screen *pscreen; |
| |
| mtx_t fence_lock; |
| struct val_device_extension_table enabled_extensions; |
| struct val_device_dispatch_table dispatch; |
| }; |
| |
| void val_device_get_cache_uuid(void *uuid); |
| |
| struct val_device_memory { |
| struct vk_object_base base; |
| struct pipe_memory_allocation *pmem; |
| uint32_t type_index; |
| VkDeviceSize map_size; |
| void * map; |
| }; |
| |
| struct val_image { |
| struct vk_object_base base; |
| VkImageType type; |
| VkFormat vk_format; |
| VkDeviceSize size; |
| uint32_t alignment; |
| struct pipe_resource *bo; |
| }; |
| |
| static inline uint32_t |
| val_get_layerCount(const struct val_image *image, |
| const VkImageSubresourceRange *range) |
| { |
| return range->layerCount == VK_REMAINING_ARRAY_LAYERS ? |
| image->bo->array_size - range->baseArrayLayer : range->layerCount; |
| } |
| |
| static inline uint32_t |
| val_get_levelCount(const struct val_image *image, |
| const VkImageSubresourceRange *range) |
| { |
| return range->levelCount == VK_REMAINING_MIP_LEVELS ? |
| (image->bo->last_level + 1) - range->baseMipLevel : range->levelCount; |
| } |
| |
| struct val_image_create_info { |
| const VkImageCreateInfo *vk_info; |
| uint32_t bind_flags; |
| uint32_t stride; |
| }; |
| |
| VkResult |
| val_image_create(VkDevice _device, |
| const struct val_image_create_info *create_info, |
| const VkAllocationCallbacks* alloc, |
| VkImage *pImage); |
| |
| struct val_image_view { |
| struct vk_object_base base; |
| const struct val_image *image; /**< VkImageViewCreateInfo::image */ |
| |
| VkImageViewType view_type; |
| VkFormat format; |
| enum pipe_format pformat; |
| VkComponentMapping components; |
| VkImageSubresourceRange subresourceRange; |
| |
| struct pipe_surface *surface; /* have we created a pipe surface for this? */ |
| }; |
| |
| struct val_subpass_attachment { |
| uint32_t attachment; |
| VkImageLayout layout; |
| bool in_render_loop; |
| }; |
| |
| struct val_subpass { |
| uint32_t attachment_count; |
| struct val_subpass_attachment * attachments; |
| |
| uint32_t input_count; |
| uint32_t color_count; |
| struct val_subpass_attachment * input_attachments; |
| struct val_subpass_attachment * color_attachments; |
| struct val_subpass_attachment * resolve_attachments; |
| struct val_subpass_attachment * depth_stencil_attachment; |
| struct val_subpass_attachment * ds_resolve_attachment; |
| |
| /** Subpass has at least one color resolve attachment */ |
| bool has_color_resolve; |
| |
| /** Subpass has at least one color attachment */ |
| bool has_color_att; |
| |
| VkSampleCountFlagBits max_sample_count; |
| }; |
| |
| struct val_render_pass_attachment { |
| VkFormat format; |
| uint32_t samples; |
| VkAttachmentLoadOp load_op; |
| VkAttachmentLoadOp stencil_load_op; |
| VkImageLayout initial_layout; |
| VkImageLayout final_layout; |
| |
| /* The subpass id in which the attachment will be used first/last. */ |
| uint32_t first_subpass_idx; |
| uint32_t last_subpass_idx; |
| }; |
| |
| struct val_render_pass { |
| struct vk_object_base base; |
| uint32_t attachment_count; |
| uint32_t subpass_count; |
| struct val_subpass_attachment * subpass_attachments; |
| struct val_render_pass_attachment * attachments; |
| struct val_subpass subpasses[0]; |
| }; |
| |
| struct val_sampler { |
| struct vk_object_base base; |
| VkSamplerCreateInfo create_info; |
| uint32_t state[4]; |
| }; |
| |
| struct val_framebuffer { |
| struct vk_object_base base; |
| uint32_t width; |
| uint32_t height; |
| uint32_t layers; |
| |
| uint32_t attachment_count; |
| struct val_image_view * attachments[0]; |
| }; |
| |
| struct val_descriptor_set_binding_layout { |
| uint16_t descriptor_index; |
| /* Number of array elements in this binding */ |
| VkDescriptorType type; |
| uint16_t array_size; |
| bool valid; |
| |
| int16_t dynamic_index; |
| struct { |
| int16_t const_buffer_index; |
| int16_t shader_buffer_index; |
| int16_t sampler_index; |
| int16_t sampler_view_index; |
| int16_t image_index; |
| } stage[MESA_SHADER_STAGES]; |
| |
| /* Immutable samplers (or NULL if no immutable samplers) */ |
| struct val_sampler **immutable_samplers; |
| }; |
| |
| struct val_descriptor_set_layout { |
| struct vk_object_base base; |
| /* Number of bindings in this descriptor set */ |
| uint16_t binding_count; |
| |
| /* Total size of the descriptor set with room for all array entries */ |
| uint16_t size; |
| |
| /* Shader stages affected by this descriptor set */ |
| uint16_t shader_stages; |
| |
| struct { |
| uint16_t const_buffer_count; |
| uint16_t shader_buffer_count; |
| uint16_t sampler_count; |
| uint16_t sampler_view_count; |
| uint16_t image_count; |
| } stage[MESA_SHADER_STAGES]; |
| |
| /* Number of dynamic offsets used by this descriptor set */ |
| uint16_t dynamic_offset_count; |
| |
| /* Bindings in this descriptor set */ |
| struct val_descriptor_set_binding_layout binding[0]; |
| }; |
| |
| struct val_descriptor { |
| VkDescriptorType type; |
| |
| union { |
| struct { |
| struct val_image_view *image_view; |
| struct val_sampler *sampler; |
| }; |
| struct { |
| uint64_t offset; |
| uint64_t range; |
| struct val_buffer *buffer; |
| } buf; |
| struct val_buffer_view *buffer_view; |
| }; |
| }; |
| |
| struct val_descriptor_set { |
| struct vk_object_base base; |
| const struct val_descriptor_set_layout *layout; |
| struct list_head link; |
| struct val_descriptor descriptors[0]; |
| }; |
| |
| struct val_descriptor_pool { |
| struct vk_object_base base; |
| VkDescriptorPoolCreateFlags flags; |
| uint32_t max_sets; |
| |
| struct list_head sets; |
| }; |
| |
| VkResult |
| val_descriptor_set_create(struct val_device *device, |
| const struct val_descriptor_set_layout *layout, |
| struct val_descriptor_set **out_set); |
| |
| void |
| val_descriptor_set_destroy(struct val_device *device, |
| struct val_descriptor_set *set); |
| |
| struct val_pipeline_layout { |
| struct vk_object_base base; |
| struct { |
| struct val_descriptor_set_layout *layout; |
| uint32_t dynamic_offset_start; |
| } set[MAX_SETS]; |
| |
| uint32_t num_sets; |
| uint32_t push_constant_size; |
| struct { |
| bool has_dynamic_offsets; |
| } stage[MESA_SHADER_STAGES]; |
| }; |
| |
| struct val_pipeline { |
| struct vk_object_base base; |
| struct val_device * device; |
| struct val_pipeline_layout * layout; |
| |
| bool is_compute_pipeline; |
| bool force_min_sample; |
| nir_shader *pipeline_nir[MESA_SHADER_STAGES]; |
| void *shader_cso[PIPE_SHADER_TYPES]; |
| VkGraphicsPipelineCreateInfo graphics_create_info; |
| VkComputePipelineCreateInfo compute_create_info; |
| }; |
| |
| struct val_event { |
| struct vk_object_base base; |
| uint64_t event_storage; |
| }; |
| |
| struct val_fence { |
| struct vk_object_base base; |
| bool signaled; |
| struct pipe_fence_handle *handle; |
| }; |
| |
| struct val_semaphore { |
| struct vk_object_base base; |
| bool dummy; |
| }; |
| |
| struct val_buffer { |
| struct vk_object_base base; |
| struct val_device * device; |
| VkDeviceSize size; |
| |
| VkBufferUsageFlags usage; |
| VkDeviceSize offset; |
| |
| struct pipe_resource *bo; |
| uint64_t total_size; |
| }; |
| |
| struct val_buffer_view { |
| struct vk_object_base base; |
| VkFormat format; |
| enum pipe_format pformat; |
| struct val_buffer *buffer; |
| uint32_t offset; |
| uint64_t range; |
| }; |
| |
| struct val_query_pool { |
| struct vk_object_base base; |
| VkQueryType type; |
| uint32_t count; |
| enum pipe_query_type base_type; |
| struct pipe_query *queries[0]; |
| }; |
| |
| struct val_cmd_pool { |
| struct vk_object_base base; |
| VkAllocationCallbacks alloc; |
| struct list_head cmd_buffers; |
| struct list_head free_cmd_buffers; |
| }; |
| |
| |
| enum val_cmd_buffer_status { |
| VAL_CMD_BUFFER_STATUS_INVALID, |
| VAL_CMD_BUFFER_STATUS_INITIAL, |
| VAL_CMD_BUFFER_STATUS_RECORDING, |
| VAL_CMD_BUFFER_STATUS_EXECUTABLE, |
| VAL_CMD_BUFFER_STATUS_PENDING, |
| }; |
| |
| struct val_cmd_buffer { |
| struct vk_object_base base; |
| |
| struct val_device * device; |
| |
| VkCommandBufferLevel level; |
| enum val_cmd_buffer_status status; |
| struct val_cmd_pool * pool; |
| struct list_head pool_link; |
| |
| struct list_head cmds; |
| |
| uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE]; |
| }; |
| |
| /* in same order and buffer building commands in spec. */ |
| enum val_cmds { |
| VAL_CMD_BIND_PIPELINE, |
| VAL_CMD_SET_VIEWPORT, |
| VAL_CMD_SET_SCISSOR, |
| VAL_CMD_SET_LINE_WIDTH, |
| VAL_CMD_SET_DEPTH_BIAS, |
| VAL_CMD_SET_BLEND_CONSTANTS, |
| VAL_CMD_SET_DEPTH_BOUNDS, |
| VAL_CMD_SET_STENCIL_COMPARE_MASK, |
| VAL_CMD_SET_STENCIL_WRITE_MASK, |
| VAL_CMD_SET_STENCIL_REFERENCE, |
| VAL_CMD_BIND_DESCRIPTOR_SETS, |
| VAL_CMD_BIND_INDEX_BUFFER, |
| VAL_CMD_BIND_VERTEX_BUFFERS, |
| VAL_CMD_DRAW, |
| VAL_CMD_DRAW_INDEXED, |
| VAL_CMD_DRAW_INDIRECT, |
| VAL_CMD_DRAW_INDEXED_INDIRECT, |
| VAL_CMD_DISPATCH, |
| VAL_CMD_DISPATCH_INDIRECT, |
| VAL_CMD_COPY_BUFFER, |
| VAL_CMD_COPY_IMAGE, |
| VAL_CMD_BLIT_IMAGE, |
| VAL_CMD_COPY_BUFFER_TO_IMAGE, |
| VAL_CMD_COPY_IMAGE_TO_BUFFER, |
| VAL_CMD_UPDATE_BUFFER, |
| VAL_CMD_FILL_BUFFER, |
| VAL_CMD_CLEAR_COLOR_IMAGE, |
| VAL_CMD_CLEAR_DEPTH_STENCIL_IMAGE, |
| VAL_CMD_CLEAR_ATTACHMENTS, |
| VAL_CMD_RESOLVE_IMAGE, |
| VAL_CMD_SET_EVENT, |
| VAL_CMD_RESET_EVENT, |
| VAL_CMD_WAIT_EVENTS, |
| VAL_CMD_PIPELINE_BARRIER, |
| VAL_CMD_BEGIN_QUERY, |
| VAL_CMD_END_QUERY, |
| VAL_CMD_RESET_QUERY_POOL, |
| VAL_CMD_WRITE_TIMESTAMP, |
| VAL_CMD_COPY_QUERY_POOL_RESULTS, |
| VAL_CMD_PUSH_CONSTANTS, |
| VAL_CMD_BEGIN_RENDER_PASS, |
| VAL_CMD_NEXT_SUBPASS, |
| VAL_CMD_END_RENDER_PASS, |
| VAL_CMD_EXECUTE_COMMANDS, |
| }; |
| |
| struct val_cmd_bind_pipeline { |
| VkPipelineBindPoint bind_point; |
| struct val_pipeline *pipeline; |
| }; |
| |
| struct val_cmd_set_viewport { |
| uint32_t first_viewport; |
| uint32_t viewport_count; |
| VkViewport viewports[16]; |
| }; |
| |
| struct val_cmd_set_scissor { |
| uint32_t first_scissor; |
| uint32_t scissor_count; |
| VkRect2D scissors[16]; |
| }; |
| |
| struct val_cmd_set_line_width { |
| float line_width; |
| }; |
| |
| struct val_cmd_set_depth_bias { |
| float constant_factor; |
| float clamp; |
| float slope_factor; |
| }; |
| |
| struct val_cmd_set_blend_constants { |
| float blend_constants[4]; |
| }; |
| |
| struct val_cmd_set_depth_bounds { |
| float min_depth; |
| float max_depth; |
| }; |
| |
| struct val_cmd_set_stencil_vals { |
| VkStencilFaceFlags face_mask; |
| uint32_t value; |
| }; |
| |
| struct val_cmd_bind_descriptor_sets { |
| VkPipelineBindPoint bind_point; |
| struct val_pipeline_layout *layout; |
| uint32_t first; |
| uint32_t count; |
| struct val_descriptor_set **sets; |
| uint32_t dynamic_offset_count; |
| const uint32_t *dynamic_offsets; |
| }; |
| |
| struct val_cmd_bind_index_buffer { |
| const struct val_buffer *buffer; |
| VkDeviceSize offset; |
| VkIndexType index_type; |
| }; |
| |
| struct val_cmd_bind_vertex_buffers { |
| uint32_t first; |
| uint32_t binding_count; |
| struct val_buffer **buffers; |
| const VkDeviceSize *offsets; |
| }; |
| |
| struct val_cmd_draw { |
| uint32_t vertex_count; |
| uint32_t instance_count; |
| uint32_t first_vertex; |
| uint32_t first_instance; |
| }; |
| |
| struct val_cmd_draw_indexed { |
| uint32_t index_count; |
| uint32_t instance_count; |
| uint32_t first_index; |
| uint32_t vertex_offset; |
| uint32_t first_instance; |
| }; |
| |
| struct val_cmd_draw_indirect { |
| VkDeviceSize offset; |
| struct val_buffer *buffer; |
| uint32_t draw_count; |
| uint32_t stride; |
| }; |
| |
| struct val_cmd_dispatch { |
| uint32_t x; |
| uint32_t y; |
| uint32_t z; |
| }; |
| |
| struct val_cmd_dispatch_indirect { |
| const struct val_buffer *buffer; |
| VkDeviceSize offset; |
| }; |
| |
| struct val_cmd_copy_buffer { |
| struct val_buffer *src; |
| struct val_buffer *dst; |
| uint32_t region_count; |
| const VkBufferCopy *regions; |
| }; |
| |
| struct val_cmd_copy_image { |
| struct val_image *src; |
| struct val_image *dst; |
| VkImageLayout src_layout; |
| VkImageLayout dst_layout; |
| uint32_t region_count; |
| const VkImageCopy *regions; |
| }; |
| |
| struct val_cmd_blit_image { |
| struct val_image *src; |
| struct val_image *dst; |
| VkImageLayout src_layout; |
| VkImageLayout dst_layout; |
| uint32_t region_count; |
| const VkImageBlit *regions; |
| VkFilter filter; |
| }; |
| |
| struct val_cmd_copy_buffer_to_image { |
| struct val_buffer *src; |
| struct val_image *dst; |
| VkImageLayout dst_layout; |
| uint32_t region_count; |
| const VkBufferImageCopy *regions; |
| }; |
| |
| struct val_cmd_copy_image_to_buffer { |
| struct val_image *src; |
| struct val_buffer *dst; |
| VkImageLayout src_layout; |
| uint32_t region_count; |
| const VkBufferImageCopy *regions; |
| }; |
| |
| struct val_cmd_update_buffer { |
| struct val_buffer *buffer; |
| VkDeviceSize offset; |
| VkDeviceSize data_size; |
| char data[0]; |
| }; |
| |
| struct val_cmd_fill_buffer { |
| struct val_buffer *buffer; |
| VkDeviceSize offset; |
| VkDeviceSize fill_size; |
| uint32_t data; |
| }; |
| |
| struct val_cmd_clear_color_image { |
| struct val_image *image; |
| VkImageLayout layout; |
| VkClearColorValue clear_val; |
| uint32_t range_count; |
| VkImageSubresourceRange *ranges; |
| }; |
| |
| struct val_cmd_clear_ds_image { |
| struct val_image *image; |
| VkImageLayout layout; |
| VkClearDepthStencilValue clear_val; |
| uint32_t range_count; |
| VkImageSubresourceRange *ranges; |
| }; |
| |
| struct val_cmd_clear_attachments { |
| uint32_t attachment_count; |
| VkClearAttachment *attachments; |
| uint32_t rect_count; |
| VkClearRect *rects; |
| }; |
| |
| struct val_cmd_resolve_image { |
| struct val_image *src; |
| struct val_image *dst; |
| VkImageLayout src_layout; |
| VkImageLayout dst_layout; |
| uint32_t region_count; |
| VkImageResolve *regions; |
| }; |
| |
| struct val_cmd_event_set { |
| struct val_event *event; |
| bool value; |
| bool flush; |
| }; |
| |
| struct val_cmd_wait_events { |
| uint32_t event_count; |
| struct val_event **events; |
| VkPipelineStageFlags src_stage_mask; |
| VkPipelineStageFlags dst_stage_mask; |
| uint32_t memory_barrier_count; |
| VkMemoryBarrier *memory_barriers; |
| uint32_t buffer_memory_barrier_count; |
| VkBufferMemoryBarrier *buffer_memory_barriers; |
| uint32_t image_memory_barrier_count; |
| VkImageMemoryBarrier *image_memory_barriers; |
| }; |
| |
| struct val_cmd_pipeline_barrier { |
| VkPipelineStageFlags src_stage_mask; |
| VkPipelineStageFlags dst_stage_mask; |
| bool by_region; |
| uint32_t memory_barrier_count; |
| VkMemoryBarrier *memory_barriers; |
| uint32_t buffer_memory_barrier_count; |
| VkBufferMemoryBarrier *buffer_memory_barriers; |
| uint32_t image_memory_barrier_count; |
| VkImageMemoryBarrier *image_memory_barriers; |
| }; |
| |
| struct val_cmd_query_cmd { |
| struct val_query_pool *pool; |
| uint32_t query; |
| uint32_t index; |
| bool precise; |
| bool flush; |
| }; |
| |
| struct val_cmd_copy_query_pool_results { |
| struct val_query_pool *pool; |
| uint32_t first_query; |
| uint32_t query_count; |
| struct val_buffer *dst; |
| VkDeviceSize dst_offset; |
| VkDeviceSize stride; |
| VkQueryResultFlags flags; |
| }; |
| |
| struct val_cmd_push_constants { |
| VkShaderStageFlags stage; |
| uint32_t offset; |
| uint32_t size; |
| uint32_t val[1]; |
| }; |
| |
| struct val_attachment_state { |
| VkImageAspectFlags pending_clear_aspects; |
| VkClearValue clear_value; |
| }; |
| |
| struct val_cmd_begin_render_pass { |
| struct val_framebuffer *framebuffer; |
| struct val_render_pass *render_pass; |
| VkRect2D render_area; |
| struct val_attachment_state *attachments; |
| }; |
| |
| struct val_cmd_next_subpass { |
| VkSubpassContents contents; |
| }; |
| |
| struct val_cmd_execute_commands { |
| uint32_t command_buffer_count; |
| struct val_cmd_buffer *cmd_buffers[0]; |
| }; |
| |
| struct val_cmd_buffer_entry { |
| struct list_head cmd_link; |
| uint32_t cmd_type; |
| union { |
| struct val_cmd_bind_pipeline pipeline; |
| struct val_cmd_set_viewport set_viewport; |
| struct val_cmd_set_scissor set_scissor; |
| struct val_cmd_set_line_width set_line_width; |
| struct val_cmd_set_depth_bias set_depth_bias; |
| struct val_cmd_set_blend_constants set_blend_constants; |
| struct val_cmd_set_depth_bounds set_depth_bounds; |
| struct val_cmd_set_stencil_vals stencil_vals; |
| struct val_cmd_bind_descriptor_sets descriptor_sets; |
| struct val_cmd_bind_vertex_buffers vertex_buffers; |
| struct val_cmd_bind_index_buffer index_buffer; |
| struct val_cmd_draw draw; |
| struct val_cmd_draw_indexed draw_indexed; |
| struct val_cmd_draw_indirect draw_indirect; |
| struct val_cmd_dispatch dispatch; |
| struct val_cmd_dispatch_indirect dispatch_indirect; |
| struct val_cmd_copy_buffer copy_buffer; |
| struct val_cmd_copy_image copy_image; |
| struct val_cmd_blit_image blit_image; |
| struct val_cmd_copy_buffer_to_image buffer_to_img; |
| struct val_cmd_copy_image_to_buffer img_to_buffer; |
| struct val_cmd_update_buffer update_buffer; |
| struct val_cmd_fill_buffer fill_buffer; |
| struct val_cmd_clear_color_image clear_color_image; |
| struct val_cmd_clear_ds_image clear_ds_image; |
| struct val_cmd_clear_attachments clear_attachments; |
| struct val_cmd_resolve_image resolve_image; |
| struct val_cmd_event_set event_set; |
| struct val_cmd_wait_events wait_events; |
| struct val_cmd_pipeline_barrier pipeline_barrier; |
| struct val_cmd_query_cmd query; |
| struct val_cmd_copy_query_pool_results copy_query_pool_results; |
| struct val_cmd_push_constants push_constants; |
| struct val_cmd_begin_render_pass begin_render_pass; |
| struct val_cmd_next_subpass next_subpass; |
| struct val_cmd_execute_commands execute_commands; |
| } u; |
| }; |
| |
| VkResult val_execute_cmds(struct val_device *device, |
| struct val_queue *queue, |
| struct val_fence *fence, |
| struct val_cmd_buffer *cmd_buffer); |
| |
| enum pipe_format vk_format_to_pipe(VkFormat format); |
| |
| static inline VkImageAspectFlags |
| vk_format_aspects(VkFormat format) |
| { |
| switch (format) { |
| case VK_FORMAT_UNDEFINED: |
| return 0; |
| |
| case VK_FORMAT_S8_UINT: |
| return VK_IMAGE_ASPECT_STENCIL_BIT; |
| |
| case VK_FORMAT_D16_UNORM_S8_UINT: |
| case VK_FORMAT_D24_UNORM_S8_UINT: |
| case VK_FORMAT_D32_SFLOAT_S8_UINT: |
| return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; |
| |
| case VK_FORMAT_D16_UNORM: |
| case VK_FORMAT_X8_D24_UNORM_PACK32: |
| case VK_FORMAT_D32_SFLOAT: |
| return VK_IMAGE_ASPECT_DEPTH_BIT; |
| |
| default: |
| return VK_IMAGE_ASPECT_COLOR_BIT; |
| } |
| } |
| |
| #ifdef __cplusplus |
| } |
| #endif |
