4340 lines
204 KiB
C++
4340 lines
204 KiB
C++
#ifndef __mock_icd_h_
|
|
#define __mock_icd_h_ 1
|
|
|
|
/*
|
|
** Copyright (c) 2015-2018 The Khronos Group Inc.
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
** This header is generated from the Khronos Vulkan XML API Registry.
|
|
**
|
|
*/
|
|
|
|
#include <unordered_map>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include "vulkan/vk_icd.h"
|
|
namespace vkmock {
|
|
|
|
|
|
using mutex_t = std::mutex;
|
|
using lock_guard_t = std::lock_guard<mutex_t>;
|
|
using unique_lock_t = std::unique_lock<mutex_t>;
|
|
|
|
static mutex_t global_lock;
|
|
static uint64_t global_unique_handle = 1;
|
|
static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5;
|
|
static uint32_t loader_interface_version = 0;
|
|
static bool negotiate_loader_icd_interface_called = false;
|
|
static void* CreateDispObjHandle() {
|
|
auto handle = new VK_LOADER_DATA;
|
|
set_loader_magic_value(handle);
|
|
return handle;
|
|
}
|
|
static void DestroyDispObjHandle(void* handle) {
|
|
delete reinterpret_cast<VK_LOADER_DATA*>(handle);
|
|
}
|
|
|
|
// Map of instance extension name to version
|
|
static const std::unordered_map<std::string, uint32_t> instance_extension_map = {
|
|
{"VK_KHR_surface", 25},
|
|
{"VK_KHR_display", 23},
|
|
{"VK_KHR_xlib_surface", 6},
|
|
{"VK_KHR_xcb_surface", 6},
|
|
{"VK_KHR_wayland_surface", 6},
|
|
{"VK_KHR_android_surface", 6},
|
|
{"VK_KHR_win32_surface", 6},
|
|
{"VK_EXT_debug_report", 10},
|
|
{"VK_GGP_stream_descriptor_surface", 1},
|
|
{"VK_NV_external_memory_capabilities", 1},
|
|
{"VK_KHR_get_physical_device_properties2", 2},
|
|
{"VK_EXT_validation_flags", 2},
|
|
{"VK_NN_vi_surface", 1},
|
|
{"VK_KHR_device_group_creation", 1},
|
|
{"VK_KHR_external_memory_capabilities", 1},
|
|
{"VK_KHR_external_semaphore_capabilities", 1},
|
|
{"VK_EXT_direct_mode_display", 1},
|
|
{"VK_EXT_acquire_xlib_display", 1},
|
|
{"VK_EXT_display_surface_counter", 1},
|
|
{"VK_EXT_swapchain_colorspace", 4},
|
|
{"VK_KHR_external_fence_capabilities", 1},
|
|
{"VK_KHR_get_surface_capabilities2", 1},
|
|
{"VK_KHR_get_display_properties2", 1},
|
|
{"VK_MVK_ios_surface", 3},
|
|
{"VK_MVK_macos_surface", 3},
|
|
{"VK_EXT_debug_utils", 2},
|
|
{"VK_FUCHSIA_imagepipe_surface", 1},
|
|
{"VK_EXT_metal_surface", 1},
|
|
{"VK_KHR_surface_protected_capabilities", 1},
|
|
{"VK_EXT_validation_features", 5},
|
|
{"VK_EXT_headless_surface", 1},
|
|
{"VK_EXT_acquire_drm_display", 1},
|
|
{"VK_EXT_directfb_surface", 1},
|
|
{"VK_QNX_screen_surface", 1},
|
|
{"VK_KHR_portability_enumeration", 1},
|
|
{"VK_GOOGLE_surfaceless_query", 1},
|
|
};
|
|
// Map of device extension name to version
|
|
static const std::unordered_map<std::string, uint32_t> device_extension_map = {
|
|
{"VK_KHR_swapchain", 70},
|
|
{"VK_KHR_display_swapchain", 10},
|
|
{"VK_NV_glsl_shader", 1},
|
|
{"VK_EXT_depth_range_unrestricted", 1},
|
|
{"VK_KHR_sampler_mirror_clamp_to_edge", 3},
|
|
{"VK_IMG_filter_cubic", 1},
|
|
{"VK_AMD_rasterization_order", 1},
|
|
{"VK_AMD_shader_trinary_minmax", 1},
|
|
{"VK_AMD_shader_explicit_vertex_parameter", 1},
|
|
{"VK_EXT_debug_marker", 4},
|
|
{"VK_KHR_video_queue", 3},
|
|
{"VK_KHR_video_decode_queue", 4},
|
|
{"VK_AMD_gcn_shader", 1},
|
|
{"VK_NV_dedicated_allocation", 1},
|
|
{"VK_EXT_transform_feedback", 1},
|
|
{"VK_NVX_binary_import", 1},
|
|
{"VK_NVX_image_view_handle", 2},
|
|
{"VK_AMD_draw_indirect_count", 2},
|
|
{"VK_AMD_negative_viewport_height", 1},
|
|
{"VK_AMD_gpu_shader_half_float", 2},
|
|
{"VK_AMD_shader_ballot", 1},
|
|
{"VK_EXT_video_encode_h264", 7},
|
|
{"VK_EXT_video_encode_h265", 7},
|
|
{"VK_EXT_video_decode_h264", 5},
|
|
{"VK_AMD_texture_gather_bias_lod", 1},
|
|
{"VK_AMD_shader_info", 1},
|
|
{"VK_KHR_dynamic_rendering", 1},
|
|
{"VK_AMD_shader_image_load_store_lod", 1},
|
|
{"VK_NV_corner_sampled_image", 2},
|
|
{"VK_KHR_multiview", 1},
|
|
{"VK_IMG_format_pvrtc", 1},
|
|
{"VK_NV_external_memory", 1},
|
|
{"VK_NV_external_memory_win32", 1},
|
|
{"VK_NV_win32_keyed_mutex", 2},
|
|
{"VK_KHR_device_group", 4},
|
|
{"VK_KHR_shader_draw_parameters", 1},
|
|
{"VK_EXT_shader_subgroup_ballot", 1},
|
|
{"VK_EXT_shader_subgroup_vote", 1},
|
|
{"VK_EXT_texture_compression_astc_hdr", 1},
|
|
{"VK_EXT_astc_decode_mode", 1},
|
|
{"VK_KHR_maintenance1", 2},
|
|
{"VK_KHR_external_memory", 1},
|
|
{"VK_KHR_external_memory_win32", 1},
|
|
{"VK_KHR_external_memory_fd", 1},
|
|
{"VK_KHR_win32_keyed_mutex", 1},
|
|
{"VK_KHR_external_semaphore", 1},
|
|
{"VK_KHR_external_semaphore_win32", 1},
|
|
{"VK_KHR_external_semaphore_fd", 1},
|
|
{"VK_KHR_push_descriptor", 2},
|
|
{"VK_EXT_conditional_rendering", 2},
|
|
{"VK_KHR_shader_float16_int8", 1},
|
|
{"VK_KHR_16bit_storage", 1},
|
|
{"VK_KHR_incremental_present", 2},
|
|
{"VK_KHR_descriptor_update_template", 1},
|
|
{"VK_NV_clip_space_w_scaling", 1},
|
|
{"VK_EXT_display_control", 1},
|
|
{"VK_GOOGLE_display_timing", 1},
|
|
{"VK_NV_sample_mask_override_coverage", 1},
|
|
{"VK_NV_geometry_shader_passthrough", 1},
|
|
{"VK_NV_viewport_array2", 1},
|
|
{"VK_NVX_multiview_per_view_attributes", 1},
|
|
{"VK_NV_viewport_swizzle", 1},
|
|
{"VK_EXT_discard_rectangles", 1},
|
|
{"VK_EXT_conservative_rasterization", 1},
|
|
{"VK_EXT_depth_clip_enable", 1},
|
|
{"VK_EXT_hdr_metadata", 2},
|
|
{"VK_KHR_imageless_framebuffer", 1},
|
|
{"VK_KHR_create_renderpass2", 1},
|
|
{"VK_KHR_shared_presentable_image", 1},
|
|
{"VK_KHR_external_fence", 1},
|
|
{"VK_KHR_external_fence_win32", 1},
|
|
{"VK_KHR_external_fence_fd", 1},
|
|
{"VK_KHR_performance_query", 1},
|
|
{"VK_KHR_maintenance2", 1},
|
|
{"VK_KHR_variable_pointers", 1},
|
|
{"VK_EXT_external_memory_dma_buf", 1},
|
|
{"VK_EXT_queue_family_foreign", 1},
|
|
{"VK_KHR_dedicated_allocation", 3},
|
|
{"VK_ANDROID_external_memory_android_hardware_buffer", 5},
|
|
{"VK_EXT_sampler_filter_minmax", 2},
|
|
{"VK_KHR_storage_buffer_storage_class", 1},
|
|
{"VK_AMD_gpu_shader_int16", 2},
|
|
{"VK_AMD_mixed_attachment_samples", 1},
|
|
{"VK_AMD_shader_fragment_mask", 1},
|
|
{"VK_EXT_inline_uniform_block", 1},
|
|
{"VK_EXT_shader_stencil_export", 1},
|
|
{"VK_EXT_sample_locations", 1},
|
|
{"VK_KHR_relaxed_block_layout", 1},
|
|
{"VK_KHR_get_memory_requirements2", 1},
|
|
{"VK_KHR_image_format_list", 1},
|
|
{"VK_EXT_blend_operation_advanced", 2},
|
|
{"VK_NV_fragment_coverage_to_color", 1},
|
|
{"VK_KHR_acceleration_structure", 13},
|
|
{"VK_KHR_ray_tracing_pipeline", 1},
|
|
{"VK_KHR_ray_query", 1},
|
|
{"VK_NV_framebuffer_mixed_samples", 1},
|
|
{"VK_NV_fill_rectangle", 1},
|
|
{"VK_NV_shader_sm_builtins", 1},
|
|
{"VK_EXT_post_depth_coverage", 1},
|
|
{"VK_KHR_sampler_ycbcr_conversion", 14},
|
|
{"VK_KHR_bind_memory2", 1},
|
|
{"VK_EXT_image_drm_format_modifier", 2},
|
|
{"VK_EXT_descriptor_indexing", 2},
|
|
{"VK_EXT_shader_viewport_index_layer", 1},
|
|
{"VK_NV_shading_rate_image", 3},
|
|
{"VK_NV_ray_tracing", 3},
|
|
{"VK_NV_representative_fragment_test", 2},
|
|
{"VK_KHR_maintenance3", 1},
|
|
{"VK_KHR_draw_indirect_count", 1},
|
|
{"VK_EXT_filter_cubic", 3},
|
|
{"VK_QCOM_render_pass_shader_resolve", 4},
|
|
{"VK_EXT_global_priority", 2},
|
|
{"VK_KHR_shader_subgroup_extended_types", 1},
|
|
{"VK_KHR_8bit_storage", 1},
|
|
{"VK_EXT_external_memory_host", 1},
|
|
{"VK_AMD_buffer_marker", 1},
|
|
{"VK_KHR_shader_atomic_int64", 1},
|
|
{"VK_KHR_shader_clock", 1},
|
|
{"VK_AMD_pipeline_compiler_control", 1},
|
|
{"VK_EXT_calibrated_timestamps", 2},
|
|
{"VK_AMD_shader_core_properties", 2},
|
|
{"VK_EXT_video_decode_h265", 3},
|
|
{"VK_KHR_global_priority", 1},
|
|
{"VK_AMD_memory_overallocation_behavior", 1},
|
|
{"VK_EXT_vertex_attribute_divisor", 3},
|
|
{"VK_GGP_frame_token", 1},
|
|
{"VK_EXT_pipeline_creation_feedback", 1},
|
|
{"VK_KHR_driver_properties", 1},
|
|
{"VK_KHR_shader_float_controls", 4},
|
|
{"VK_NV_shader_subgroup_partitioned", 1},
|
|
{"VK_KHR_depth_stencil_resolve", 1},
|
|
{"VK_KHR_swapchain_mutable_format", 1},
|
|
{"VK_NV_compute_shader_derivatives", 1},
|
|
{"VK_NV_mesh_shader", 1},
|
|
{"VK_NV_fragment_shader_barycentric", 1},
|
|
{"VK_NV_shader_image_footprint", 2},
|
|
{"VK_NV_scissor_exclusive", 1},
|
|
{"VK_NV_device_diagnostic_checkpoints", 2},
|
|
{"VK_KHR_timeline_semaphore", 2},
|
|
{"VK_INTEL_shader_integer_functions2", 1},
|
|
{"VK_INTEL_performance_query", 2},
|
|
{"VK_KHR_vulkan_memory_model", 3},
|
|
{"VK_EXT_pci_bus_info", 2},
|
|
{"VK_AMD_display_native_hdr", 1},
|
|
{"VK_KHR_shader_terminate_invocation", 1},
|
|
{"VK_EXT_fragment_density_map", 2},
|
|
{"VK_EXT_scalar_block_layout", 1},
|
|
{"VK_GOOGLE_hlsl_functionality1", 1},
|
|
{"VK_GOOGLE_decorate_string", 1},
|
|
{"VK_EXT_subgroup_size_control", 2},
|
|
{"VK_KHR_fragment_shading_rate", 2},
|
|
{"VK_AMD_shader_core_properties2", 1},
|
|
{"VK_AMD_device_coherent_memory", 1},
|
|
{"VK_EXT_shader_image_atomic_int64", 1},
|
|
{"VK_KHR_spirv_1_4", 1},
|
|
{"VK_EXT_memory_budget", 1},
|
|
{"VK_EXT_memory_priority", 1},
|
|
{"VK_NV_dedicated_allocation_image_aliasing", 1},
|
|
{"VK_KHR_separate_depth_stencil_layouts", 1},
|
|
{"VK_EXT_buffer_device_address", 2},
|
|
{"VK_EXT_tooling_info", 1},
|
|
{"VK_EXT_separate_stencil_usage", 1},
|
|
{"VK_KHR_present_wait", 1},
|
|
{"VK_NV_cooperative_matrix", 1},
|
|
{"VK_NV_coverage_reduction_mode", 1},
|
|
{"VK_EXT_fragment_shader_interlock", 1},
|
|
{"VK_EXT_ycbcr_image_arrays", 1},
|
|
{"VK_KHR_uniform_buffer_standard_layout", 1},
|
|
{"VK_EXT_provoking_vertex", 1},
|
|
{"VK_EXT_full_screen_exclusive", 4},
|
|
{"VK_KHR_buffer_device_address", 1},
|
|
{"VK_EXT_line_rasterization", 1},
|
|
{"VK_EXT_shader_atomic_float", 1},
|
|
{"VK_EXT_host_query_reset", 1},
|
|
{"VK_EXT_index_type_uint8", 1},
|
|
{"VK_EXT_extended_dynamic_state", 1},
|
|
{"VK_KHR_deferred_host_operations", 4},
|
|
{"VK_KHR_pipeline_executable_properties", 1},
|
|
{"VK_EXT_shader_atomic_float2", 1},
|
|
{"VK_EXT_shader_demote_to_helper_invocation", 1},
|
|
{"VK_NV_device_generated_commands", 3},
|
|
{"VK_NV_inherited_viewport_scissor", 1},
|
|
{"VK_KHR_shader_integer_dot_product", 1},
|
|
{"VK_EXT_texel_buffer_alignment", 1},
|
|
{"VK_QCOM_render_pass_transform", 2},
|
|
{"VK_EXT_device_memory_report", 2},
|
|
{"VK_EXT_robustness2", 1},
|
|
{"VK_EXT_custom_border_color", 12},
|
|
{"VK_GOOGLE_user_type", 1},
|
|
{"VK_KHR_pipeline_library", 1},
|
|
{"VK_KHR_shader_non_semantic_info", 1},
|
|
{"VK_KHR_present_id", 1},
|
|
{"VK_EXT_private_data", 1},
|
|
{"VK_EXT_pipeline_creation_cache_control", 3},
|
|
{"VK_KHR_video_encode_queue", 5},
|
|
{"VK_NV_device_diagnostics_config", 1},
|
|
{"VK_QCOM_render_pass_store_ops", 2},
|
|
{"VK_KHR_synchronization2", 1},
|
|
{"VK_EXT_graphics_pipeline_library", 1},
|
|
{"VK_KHR_shader_subgroup_uniform_control_flow", 1},
|
|
{"VK_KHR_zero_initialize_workgroup_memory", 1},
|
|
{"VK_NV_fragment_shading_rate_enums", 1},
|
|
{"VK_NV_ray_tracing_motion_blur", 1},
|
|
{"VK_EXT_ycbcr_2plane_444_formats", 1},
|
|
{"VK_EXT_fragment_density_map2", 1},
|
|
{"VK_QCOM_rotated_copy_commands", 1},
|
|
{"VK_EXT_image_robustness", 1},
|
|
{"VK_KHR_workgroup_memory_explicit_layout", 1},
|
|
{"VK_KHR_copy_commands2", 1},
|
|
{"VK_EXT_4444_formats", 1},
|
|
{"VK_ARM_rasterization_order_attachment_access", 1},
|
|
{"VK_EXT_rgba10x6_formats", 1},
|
|
{"VK_NV_acquire_winrt_display", 1},
|
|
{"VK_VALVE_mutable_descriptor_type", 1},
|
|
{"VK_EXT_vertex_input_dynamic_state", 2},
|
|
{"VK_EXT_physical_device_drm", 1},
|
|
{"VK_EXT_depth_clip_control", 1},
|
|
{"VK_EXT_primitive_topology_list_restart", 1},
|
|
{"VK_KHR_format_feature_flags2", 1},
|
|
{"VK_FUCHSIA_external_memory", 1},
|
|
{"VK_FUCHSIA_external_semaphore", 1},
|
|
{"VK_FUCHSIA_buffer_collection", 2},
|
|
{"VK_HUAWEI_subpass_shading", 2},
|
|
{"VK_HUAWEI_invocation_mask", 1},
|
|
{"VK_NV_external_memory_rdma", 1},
|
|
{"VK_EXT_extended_dynamic_state2", 1},
|
|
{"VK_EXT_color_write_enable", 1},
|
|
{"VK_EXT_primitives_generated_query", 1},
|
|
{"VK_EXT_global_priority_query", 1},
|
|
{"VK_EXT_image_view_min_lod", 1},
|
|
{"VK_EXT_multi_draw", 1},
|
|
{"VK_EXT_image_2d_view_of_3d", 1},
|
|
{"VK_EXT_load_store_op_none", 1},
|
|
{"VK_EXT_border_color_swizzle", 1},
|
|
{"VK_EXT_pageable_device_local_memory", 1},
|
|
{"VK_KHR_maintenance4", 2},
|
|
{"VK_VALVE_descriptor_set_host_mapping", 1},
|
|
{"VK_QCOM_fragment_density_map_offset", 1},
|
|
{"VK_NV_linear_color_attachment", 1},
|
|
};
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
|
|
const VkInstanceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkInstance* pInstance);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyInstance(
|
|
VkInstance instance,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceCount,
|
|
VkPhysicalDevice* pPhysicalDevices);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures* pFeatures);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties* pFormatProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkImageTiling tiling,
|
|
VkImageUsageFlags usage,
|
|
VkImageCreateFlags flags,
|
|
VkImageFormatProperties* pImageFormatProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties* pProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties* pQueueFamilyProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties* pMemoryProperties);
|
|
|
|
static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
|
|
VkInstance instance,
|
|
const char* pName);
|
|
|
|
static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
|
|
VkDevice device,
|
|
const char* pName);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDeviceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDevice* pDevice);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDevice(
|
|
VkDevice device,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
|
|
const char* pLayerName,
|
|
uint32_t* pPropertyCount,
|
|
VkExtensionProperties* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const char* pLayerName,
|
|
uint32_t* pPropertyCount,
|
|
VkExtensionProperties* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
|
|
uint32_t* pPropertyCount,
|
|
VkLayerProperties* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkLayerProperties* pProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
|
|
VkDevice device,
|
|
uint32_t queueFamilyIndex,
|
|
uint32_t queueIndex,
|
|
VkQueue* pQueue);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
|
|
VkQueue queue,
|
|
uint32_t submitCount,
|
|
const VkSubmitInfo* pSubmits,
|
|
VkFence fence);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
|
|
VkQueue queue);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
|
|
VkDevice device);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
|
|
VkDevice device,
|
|
const VkMemoryAllocateInfo* pAllocateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDeviceMemory* pMemory);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL FreeMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize offset,
|
|
VkDeviceSize size,
|
|
VkMemoryMapFlags flags,
|
|
void** ppData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL UnmapMemory(
|
|
VkDevice device,
|
|
VkDeviceMemory memory);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
|
|
VkDevice device,
|
|
uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange* pMemoryRanges);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
|
|
VkDevice device,
|
|
uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange* pMemoryRanges);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize* pCommittedMemoryInBytes);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
VkMemoryRequirements* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkMemoryRequirements* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
|
|
VkDevice device,
|
|
VkImage image,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkSampleCountFlagBits samples,
|
|
VkImageUsageFlags usage,
|
|
VkImageTiling tiling,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
|
|
VkQueue queue,
|
|
uint32_t bindInfoCount,
|
|
const VkBindSparseInfo* pBindInfo,
|
|
VkFence fence);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
|
|
VkDevice device,
|
|
const VkFenceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyFence(
|
|
VkDevice device,
|
|
VkFence fence,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
|
|
VkDevice device,
|
|
uint32_t fenceCount,
|
|
const VkFence* pFences);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
|
|
VkDevice device,
|
|
VkFence fence);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
|
|
VkDevice device,
|
|
uint32_t fenceCount,
|
|
const VkFence* pFences,
|
|
VkBool32 waitAll,
|
|
uint64_t timeout);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
|
|
VkDevice device,
|
|
const VkSemaphoreCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSemaphore* pSemaphore);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
|
|
VkDevice device,
|
|
VkSemaphore semaphore,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
|
|
VkDevice device,
|
|
const VkEventCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkEvent* pEvent);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyEvent(
|
|
VkDevice device,
|
|
VkEvent event,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
|
|
VkDevice device,
|
|
VkEvent event);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
|
|
VkDevice device,
|
|
VkEvent event);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
|
|
VkDevice device,
|
|
VkEvent event);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
|
|
VkDevice device,
|
|
const VkQueryPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkQueryPool* pQueryPool);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount,
|
|
size_t dataSize,
|
|
void* pData,
|
|
VkDeviceSize stride,
|
|
VkQueryResultFlags flags);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
|
|
VkDevice device,
|
|
const VkBufferCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBuffer* pBuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
|
|
VkDevice device,
|
|
VkBuffer buffer,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
|
|
VkDevice device,
|
|
const VkBufferViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBufferView* pView);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
|
|
VkDevice device,
|
|
VkBufferView bufferView,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
|
|
VkDevice device,
|
|
const VkImageCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImage* pImage);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyImage(
|
|
VkDevice device,
|
|
VkImage image,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
|
|
VkDevice device,
|
|
VkImage image,
|
|
const VkImageSubresource* pSubresource,
|
|
VkSubresourceLayout* pLayout);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
|
|
VkDevice device,
|
|
const VkImageViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkImageView* pView);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyImageView(
|
|
VkDevice device,
|
|
VkImageView imageView,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
|
|
VkDevice device,
|
|
const VkShaderModuleCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkShaderModule* pShaderModule);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
|
|
VkDevice device,
|
|
VkShaderModule shaderModule,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
|
|
VkDevice device,
|
|
const VkPipelineCacheCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineCache* pPipelineCache);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
size_t* pDataSize,
|
|
void* pData);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
|
|
VkDevice device,
|
|
VkPipelineCache dstCache,
|
|
uint32_t srcCacheCount,
|
|
const VkPipelineCache* pSrcCaches);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkGraphicsPipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkComputePipelineCreateInfo* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
|
|
VkDevice device,
|
|
const VkPipelineLayoutCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipelineLayout* pPipelineLayout);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
|
|
VkDevice device,
|
|
VkPipelineLayout pipelineLayout,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
|
|
VkDevice device,
|
|
const VkSamplerCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSampler* pSampler);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySampler(
|
|
VkDevice device,
|
|
VkSampler sampler,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
|
|
VkDevice device,
|
|
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorSetLayout* pSetLayout);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
|
|
VkDevice device,
|
|
VkDescriptorSetLayout descriptorSetLayout,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
|
|
VkDevice device,
|
|
const VkDescriptorPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorPool* pDescriptorPool);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
|
|
VkDevice device,
|
|
VkDescriptorPool descriptorPool,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
|
|
VkDevice device,
|
|
VkDescriptorPool descriptorPool,
|
|
VkDescriptorPoolResetFlags flags);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
|
|
VkDevice device,
|
|
const VkDescriptorSetAllocateInfo* pAllocateInfo,
|
|
VkDescriptorSet* pDescriptorSets);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
|
|
VkDevice device,
|
|
VkDescriptorPool descriptorPool,
|
|
uint32_t descriptorSetCount,
|
|
const VkDescriptorSet* pDescriptorSets);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
|
|
VkDevice device,
|
|
uint32_t descriptorWriteCount,
|
|
const VkWriteDescriptorSet* pDescriptorWrites,
|
|
uint32_t descriptorCopyCount,
|
|
const VkCopyDescriptorSet* pDescriptorCopies);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
|
|
VkDevice device,
|
|
const VkFramebufferCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFramebuffer* pFramebuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
|
|
VkDevice device,
|
|
VkFramebuffer framebuffer,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
|
|
VkDevice device,
|
|
VkRenderPass renderPass,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
|
|
VkDevice device,
|
|
VkRenderPass renderPass,
|
|
VkExtent2D* pGranularity);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
|
|
VkDevice device,
|
|
const VkCommandPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCommandPool* pCommandPool);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolResetFlags flags);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
|
|
VkDevice device,
|
|
const VkCommandBufferAllocateInfo* pAllocateInfo,
|
|
VkCommandBuffer* pCommandBuffers);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
uint32_t commandBufferCount,
|
|
const VkCommandBuffer* pCommandBuffers);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCommandBufferBeginInfo* pBeginInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCommandBufferResetFlags flags);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipeline pipeline);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkViewport* pViewports);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstScissor,
|
|
uint32_t scissorCount,
|
|
const VkRect2D* pScissors);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
|
|
VkCommandBuffer commandBuffer,
|
|
float lineWidth);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
|
|
VkCommandBuffer commandBuffer,
|
|
float depthBiasConstantFactor,
|
|
float depthBiasClamp,
|
|
float depthBiasSlopeFactor);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
|
|
VkCommandBuffer commandBuffer,
|
|
const float blendConstants[4]);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
|
|
VkCommandBuffer commandBuffer,
|
|
float minDepthBounds,
|
|
float maxDepthBounds);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t compareMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t writeMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
uint32_t reference);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipelineLayout layout,
|
|
uint32_t firstSet,
|
|
uint32_t descriptorSetCount,
|
|
const VkDescriptorSet* pDescriptorSets,
|
|
uint32_t dynamicOffsetCount,
|
|
const uint32_t* pDynamicOffsets);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkIndexType indexType);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDraw(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t vertexCount,
|
|
uint32_t instanceCount,
|
|
uint32_t firstVertex,
|
|
uint32_t firstInstance);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t indexCount,
|
|
uint32_t instanceCount,
|
|
uint32_t firstIndex,
|
|
int32_t vertexOffset,
|
|
uint32_t firstInstance);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDispatch(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer srcBuffer,
|
|
VkBuffer dstBuffer,
|
|
uint32_t regionCount,
|
|
const VkBufferCopy* pRegions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageCopy* pRegions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageBlit* pRegions,
|
|
VkFilter filter);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer srcBuffer,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy* pRegions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkBuffer dstBuffer,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy* pRegions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize dataSize,
|
|
const void* pData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize size,
|
|
uint32_t data);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage image,
|
|
VkImageLayout imageLayout,
|
|
const VkClearColorValue* pColor,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange* pRanges);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage image,
|
|
VkImageLayout imageLayout,
|
|
const VkClearDepthStencilValue* pDepthStencil,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange* pRanges);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t attachmentCount,
|
|
const VkClearAttachment* pAttachments,
|
|
uint32_t rectCount,
|
|
const VkClearRect* pRects);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImage srcImage,
|
|
VkImageLayout srcImageLayout,
|
|
VkImage dstImage,
|
|
VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkImageResolve* pRegions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags stageMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags stageMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t eventCount,
|
|
const VkEvent* pEvents,
|
|
VkPipelineStageFlags srcStageMask,
|
|
VkPipelineStageFlags dstStageMask,
|
|
uint32_t memoryBarrierCount,
|
|
const VkMemoryBarrier* pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier* pImageMemoryBarriers);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlags srcStageMask,
|
|
VkPipelineStageFlags dstStageMask,
|
|
VkDependencyFlags dependencyFlags,
|
|
uint32_t memoryBarrierCount,
|
|
const VkMemoryBarrier* pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier* pImageMemoryBarriers);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
VkQueryControlFlags flags);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlagBits pipelineStage,
|
|
VkQueryPool queryPool,
|
|
uint32_t query);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
VkDeviceSize stride,
|
|
VkQueryResultFlags flags);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineLayout layout,
|
|
VkShaderStageFlags stageFlags,
|
|
uint32_t offset,
|
|
uint32_t size,
|
|
const void* pValues);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo* pRenderPassBegin,
|
|
VkSubpassContents contents);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
|
|
VkCommandBuffer commandBuffer,
|
|
VkSubpassContents contents);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t commandBufferCount,
|
|
const VkCommandBuffer* pCommandBuffers);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(
|
|
uint32_t* pApiVersion);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindBufferMemoryInfo* pBindInfos);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindImageMemoryInfo* pBindInfos);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
|
|
VkDevice device,
|
|
uint32_t heapIndex,
|
|
uint32_t localDeviceIndex,
|
|
uint32_t remoteDeviceIndex,
|
|
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t deviceMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t baseGroupX,
|
|
uint32_t baseGroupY,
|
|
uint32_t baseGroupZ,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceGroupCount,
|
|
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkImageMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkBufferMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
|
|
VkDevice device,
|
|
const VkImageSparseMemoryRequirementsInfo2* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures2* pFeatures);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties2* pProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties2* pFormatProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
|
|
VkImageFormatProperties2* pImageFormatProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties2* pQueueFamilyProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties2* pProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolTrimFlags flags);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
|
|
VkDevice device,
|
|
const VkDeviceQueueInfo2* pQueueInfo,
|
|
VkQueue* pQueue);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
|
|
VkDevice device,
|
|
VkDescriptorSet descriptorSet,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const void* pData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
|
|
VkExternalBufferProperties* pExternalBufferProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
|
|
VkExternalFenceProperties* pExternalFenceProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
|
|
VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
|
|
VkDevice device,
|
|
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
|
|
VkDescriptorSetLayoutSupport* pSupport);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo2* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo* pRenderPassBegin,
|
|
const VkSubpassBeginInfo* pSubpassBeginInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassBeginInfo* pSubpassBeginInfo,
|
|
const VkSubpassEndInfo* pSubpassEndInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassEndInfo* pSubpassEndInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
|
|
VkDevice device,
|
|
VkSemaphore semaphore,
|
|
uint64_t* pValue);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
|
|
VkDevice device,
|
|
const VkSemaphoreWaitInfo* pWaitInfo,
|
|
uint64_t timeout);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
|
|
VkDevice device,
|
|
const VkSemaphoreSignalInfo* pSignalInfo);
|
|
|
|
static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfo* pInfo);
|
|
|
|
static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfo* pInfo);
|
|
|
|
static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
|
|
VkDevice device,
|
|
const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pToolCount,
|
|
VkPhysicalDeviceToolProperties* pToolProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot(
|
|
VkDevice device,
|
|
const VkPrivateDataSlotCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPrivateDataSlot* pPrivateDataSlot);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot(
|
|
VkDevice device,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData(
|
|
VkDevice device,
|
|
VkObjectType objectType,
|
|
uint64_t objectHandle,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
uint64_t data);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPrivateData(
|
|
VkDevice device,
|
|
VkObjectType objectType,
|
|
uint64_t objectHandle,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
uint64_t* pData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
const VkDependencyInfo* pDependencyInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags2 stageMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t eventCount,
|
|
const VkEvent* pEvents,
|
|
const VkDependencyInfo* pDependencyInfos);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDependencyInfo* pDependencyInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlags2 stage,
|
|
VkQueryPool queryPool,
|
|
uint32_t query);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2(
|
|
VkQueue queue,
|
|
uint32_t submitCount,
|
|
const VkSubmitInfo2* pSubmits,
|
|
VkFence fence);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyBufferInfo2* pCopyBufferInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyImageInfo2* pCopyImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkBlitImageInfo2* pBlitImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkResolveImageInfo2* pResolveImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderingInfo* pRenderingInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndRendering(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCullModeFlags cullMode);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace(
|
|
VkCommandBuffer commandBuffer,
|
|
VkFrontFace frontFace);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPrimitiveTopology primitiveTopology);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t viewportCount,
|
|
const VkViewport* pViewports);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t scissorCount,
|
|
const VkRect2D* pScissors);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets,
|
|
const VkDeviceSize* pSizes,
|
|
const VkDeviceSize* pStrides);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthWriteEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCompareOp depthCompareOp);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthBoundsTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 stencilTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
VkStencilOp failOp,
|
|
VkStencilOp passOp,
|
|
VkStencilOp depthFailOp,
|
|
VkCompareOp compareOp);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 rasterizerDiscardEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthBiasEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 primitiveRestartEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements(
|
|
VkDevice device,
|
|
const VkDeviceBufferMemoryRequirements* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(
|
|
VkDevice device,
|
|
const VkDeviceImageMemoryRequirements* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements(
|
|
VkDevice device,
|
|
const VkDeviceImageMemoryRequirements* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
|
|
VkInstance instance,
|
|
VkSurfaceKHR surface,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
VkSurfaceKHR surface,
|
|
VkBool32* pSupported);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pSurfaceFormatCount,
|
|
VkSurfaceFormatKHR* pSurfaceFormats);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pPresentModeCount,
|
|
VkPresentModeKHR* pPresentModes);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
|
|
VkDevice device,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchain);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint32_t* pSwapchainImageCount,
|
|
VkImage* pSwapchainImages);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint64_t timeout,
|
|
VkSemaphore semaphore,
|
|
VkFence fence,
|
|
uint32_t* pImageIndex);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
|
|
VkQueue queue,
|
|
const VkPresentInfoKHR* pPresentInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
|
|
VkDevice device,
|
|
VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
|
|
VkDevice device,
|
|
VkSurfaceKHR surface,
|
|
VkDeviceGroupPresentModeFlagsKHR* pModes);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
uint32_t* pRectCount,
|
|
VkRect2D* pRects);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
|
|
VkDevice device,
|
|
const VkAcquireNextImageInfoKHR* pAcquireInfo,
|
|
uint32_t* pImageIndex);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayPropertiesKHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayPlanePropertiesKHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t planeIndex,
|
|
uint32_t* pDisplayCount,
|
|
VkDisplayKHR* pDisplays);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayModePropertiesKHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display,
|
|
const VkDisplayModeCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDisplayModeKHR* pMode);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayModeKHR mode,
|
|
uint32_t planeIndex,
|
|
VkDisplayPlaneCapabilitiesKHR* pCapabilities);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
|
|
VkDevice device,
|
|
uint32_t swapchainCount,
|
|
const VkSwapchainCreateInfoKHR* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSwapchainKHR* pSwapchains);
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
Display* dpy,
|
|
VisualID visualID);
|
|
#endif /* VK_USE_PLATFORM_XLIB_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
xcb_connection_t* connection,
|
|
xcb_visualid_t visual_id);
|
|
#endif /* VK_USE_PLATFORM_XCB_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
struct wl_display* display);
|
|
#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
|
|
VkInstance instance,
|
|
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_ANDROID_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkVideoProfileKHR* pVideoProfile,
|
|
VkVideoCapabilitiesKHR* pCapabilities);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo,
|
|
uint32_t* pVideoFormatPropertyCount,
|
|
VkVideoFormatPropertiesKHR* pVideoFormatProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR(
|
|
VkDevice device,
|
|
const VkVideoSessionCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkVideoSessionKHR* pVideoSession);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR(
|
|
VkDevice device,
|
|
VkVideoSessionKHR videoSession,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR(
|
|
VkDevice device,
|
|
VkVideoSessionKHR videoSession,
|
|
uint32_t* pVideoSessionMemoryRequirementsCount,
|
|
VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR(
|
|
VkDevice device,
|
|
VkVideoSessionKHR videoSession,
|
|
uint32_t videoSessionBindMemoryCount,
|
|
const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR(
|
|
VkDevice device,
|
|
const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkVideoSessionParametersKHR* pVideoSessionParameters);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR(
|
|
VkDevice device,
|
|
VkVideoSessionParametersKHR videoSessionParameters,
|
|
const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR(
|
|
VkDevice device,
|
|
VkVideoSessionParametersKHR videoSessionParameters,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkVideoBeginCodingInfoKHR* pBeginInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkVideoEndCodingInfoKHR* pEndCodingInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkVideoCodingControlInfoKHR* pCodingControlInfo);
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkVideoDecodeInfoKHR* pFrameInfo);
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderingInfo* pRenderingInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceFeatures2* pFeatures);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceProperties2* pProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkFormatProperties2* pFormatProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
|
|
VkImageFormatProperties2* pImageFormatProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties2* pQueueFamilyProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
|
|
uint32_t* pPropertyCount,
|
|
VkSparseImageFormatProperties2* pProperties);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
|
|
VkDevice device,
|
|
uint32_t heapIndex,
|
|
uint32_t localDeviceIndex,
|
|
uint32_t remoteDeviceIndex,
|
|
VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t deviceMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t baseGroupX,
|
|
uint32_t baseGroupY,
|
|
uint32_t baseGroupZ,
|
|
uint32_t groupCountX,
|
|
uint32_t groupCountY,
|
|
uint32_t groupCountZ);
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
|
|
VkDevice device,
|
|
VkCommandPool commandPool,
|
|
VkCommandPoolTrimFlags flags);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
|
|
VkInstance instance,
|
|
uint32_t* pPhysicalDeviceGroupCount,
|
|
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
|
|
VkExternalBufferProperties* pExternalBufferProperties);
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
HANDLE handle,
|
|
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
|
|
VkDevice device,
|
|
const VkMemoryGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
int fd,
|
|
VkMemoryFdPropertiesKHR* pMemoryFdProperties);
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
|
|
VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
|
|
VkDevice device,
|
|
const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipelineLayout layout,
|
|
uint32_t set,
|
|
uint32_t descriptorWriteCount,
|
|
const VkWriteDescriptorSet* pDescriptorWrites);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
VkPipelineLayout layout,
|
|
uint32_t set,
|
|
const void* pData);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
|
|
VkDevice device,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
|
|
VkDevice device,
|
|
VkDescriptorSet descriptorSet,
|
|
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
const void* pData);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
|
|
VkDevice device,
|
|
const VkRenderPassCreateInfo2* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkRenderPass* pRenderPass);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo* pRenderPassBegin,
|
|
const VkSubpassBeginInfo* pSubpassBeginInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassBeginInfo* pSubpassBeginInfo,
|
|
const VkSubpassEndInfo* pSubpassEndInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSubpassEndInfo* pSubpassEndInfo);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
|
|
VkExternalFenceProperties* pExternalFenceProperties);
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
|
|
VkDevice device,
|
|
const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
|
|
VkDevice device,
|
|
const VkFenceGetFdInfoKHR* pGetFdInfo,
|
|
int* pFd);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
uint32_t* pCounterCount,
|
|
VkPerformanceCounterKHR* pCounters,
|
|
VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
|
|
uint32_t* pNumPasses);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
|
|
VkDevice device,
|
|
const VkAcquireProfilingLockInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
|
|
VkDevice device);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
uint32_t* pSurfaceFormatCount,
|
|
VkSurfaceFormat2KHR* pSurfaceFormats);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayProperties2KHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayPlaneProperties2KHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display,
|
|
uint32_t* pPropertyCount,
|
|
VkDisplayModeProperties2KHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
|
|
VkDisplayPlaneCapabilities2KHR* pCapabilities);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkImageMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkBufferMemoryRequirementsInfo2* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
|
|
VkDevice device,
|
|
const VkImageSparseMemoryRequirementsInfo2* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSamplerYcbcrConversion* pYcbcrConversion);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
|
|
VkDevice device,
|
|
VkSamplerYcbcrConversion ycbcrConversion,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindBufferMemoryInfo* pBindInfos);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindImageMemoryInfo* pBindInfos);
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
|
|
VkDevice device,
|
|
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
|
|
VkDescriptorSetLayoutSupport* pSupport);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
|
|
VkDevice device,
|
|
VkSemaphore semaphore,
|
|
uint64_t* pValue);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreWaitInfo* pWaitInfo,
|
|
uint64_t timeout);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreSignalInfo* pSignalInfo);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pFragmentShadingRateCount,
|
|
VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkExtent2D* pFragmentSize,
|
|
const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint64_t presentId,
|
|
uint64_t timeout);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfo* pInfo);
|
|
|
|
static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfo* pInfo);
|
|
|
|
static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
|
|
VkDevice device,
|
|
const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
|
|
VkDevice device,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDeferredOperationKHR* pDeferredOperation);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR operation,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR operation);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR operation);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR operation);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
|
|
VkDevice device,
|
|
const VkPipelineInfoKHR* pPipelineInfo,
|
|
uint32_t* pExecutableCount,
|
|
VkPipelineExecutablePropertiesKHR* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
|
|
VkDevice device,
|
|
const VkPipelineExecutableInfoKHR* pExecutableInfo,
|
|
uint32_t* pStatisticCount,
|
|
VkPipelineExecutableStatisticKHR* pStatistics);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
|
|
VkDevice device,
|
|
const VkPipelineExecutableInfoKHR* pExecutableInfo,
|
|
uint32_t* pInternalRepresentationCount,
|
|
VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkVideoEncodeInfoKHR* pEncodeInfo);
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
const VkDependencyInfo* pDependencyInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkEvent event,
|
|
VkPipelineStageFlags2 stageMask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t eventCount,
|
|
const VkEvent* pEvents,
|
|
const VkDependencyInfo* pDependencyInfos);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDependencyInfo* pDependencyInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlags2 stage,
|
|
VkQueryPool queryPool,
|
|
uint32_t query);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(
|
|
VkQueue queue,
|
|
uint32_t submitCount,
|
|
const VkSubmitInfo2* pSubmits,
|
|
VkFence fence);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlags2 stage,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
uint32_t marker);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(
|
|
VkQueue queue,
|
|
uint32_t* pCheckpointDataCount,
|
|
VkCheckpointData2NV* pCheckpointData);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyBufferInfo2* pCopyBufferInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyImageInfo2* pCopyImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkBlitImageInfo2* pBlitImageInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkResolveImageInfo2* pResolveImageInfo);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(
|
|
VkDevice device,
|
|
const VkDeviceBufferMemoryRequirements* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(
|
|
VkDevice device,
|
|
const VkDeviceImageMemoryRequirements* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
|
|
VkDevice device,
|
|
const VkDeviceImageMemoryRequirements* pInfo,
|
|
uint32_t* pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugReportCallbackEXT* pCallback);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
|
|
VkInstance instance,
|
|
VkDebugReportCallbackEXT callback,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
|
|
VkInstance instance,
|
|
VkDebugReportFlagsEXT flags,
|
|
VkDebugReportObjectTypeEXT objectType,
|
|
uint64_t object,
|
|
size_t location,
|
|
int32_t messageCode,
|
|
const char* pLayerPrefix,
|
|
const char* pMessage);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
|
|
VkDevice device,
|
|
const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
|
|
VkDevice device,
|
|
const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets,
|
|
const VkDeviceSize* pSizes);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstCounterBuffer,
|
|
uint32_t counterBufferCount,
|
|
const VkBuffer* pCounterBuffers,
|
|
const VkDeviceSize* pCounterBufferOffsets);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstCounterBuffer,
|
|
uint32_t counterBufferCount,
|
|
const VkBuffer* pCounterBuffers,
|
|
const VkDeviceSize* pCounterBufferOffsets);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
VkQueryControlFlags flags,
|
|
uint32_t index);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkQueryPool queryPool,
|
|
uint32_t query,
|
|
uint32_t index);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
VkBuffer counterBuffer,
|
|
VkDeviceSize counterBufferOffset,
|
|
uint32_t counterOffset,
|
|
uint32_t vertexStride);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX(
|
|
VkDevice device,
|
|
const VkCuModuleCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCuModuleNVX* pModule);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX(
|
|
VkDevice device,
|
|
const VkCuFunctionCreateInfoNVX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCuFunctionNVX* pFunction);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX(
|
|
VkDevice device,
|
|
VkCuModuleNVX module,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX(
|
|
VkDevice device,
|
|
VkCuFunctionNVX function,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCuLaunchInfoNVX* pLaunchInfo);
|
|
|
|
|
|
static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
|
|
VkDevice device,
|
|
const VkImageViewHandleInfoNVX* pInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(
|
|
VkDevice device,
|
|
VkImageView imageView,
|
|
VkImageViewAddressPropertiesNVX* pProperties);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
|
|
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
VkShaderStageFlagBits shaderStage,
|
|
VkShaderInfoTypeAMD infoType,
|
|
size_t* pInfoSize,
|
|
void* pInfo);
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_GGP
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
|
|
VkInstance instance,
|
|
const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_GGP */
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkFormat format,
|
|
VkImageType type,
|
|
VkImageTiling tiling,
|
|
VkImageUsageFlags usage,
|
|
VkImageCreateFlags flags,
|
|
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
|
|
VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkExternalMemoryHandleTypeFlagsNV handleType,
|
|
HANDLE* pHandle);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_VI_NN
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
|
|
VkInstance instance,
|
|
const VkViSurfaceCreateInfoNN* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_VI_NN */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkViewportWScalingNV* pViewportWScalings);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display);
|
|
|
|
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
Display* dpy,
|
|
VkDisplayKHR display);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
Display* dpy,
|
|
RROutput rrOutput,
|
|
VkDisplayKHR* pDisplay);
|
|
#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSurfaceKHR surface,
|
|
VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
|
|
VkDevice device,
|
|
VkDisplayKHR display,
|
|
const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
|
|
VkDevice device,
|
|
const VkDeviceEventInfoEXT* pDeviceEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
|
|
VkDevice device,
|
|
VkDisplayKHR display,
|
|
const VkDisplayEventInfoEXT* pDisplayEventInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkFence* pFence);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
VkSurfaceCounterFlagBitsEXT counter,
|
|
uint64_t* pCounterValue);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain,
|
|
uint32_t* pPresentationTimingCount,
|
|
VkPastPresentationTimingGOOGLE* pPresentationTimings);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstDiscardRectangle,
|
|
uint32_t discardRectangleCount,
|
|
const VkRect2D* pDiscardRectangles);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
|
|
VkDevice device,
|
|
uint32_t swapchainCount,
|
|
const VkSwapchainKHR* pSwapchains,
|
|
const VkHdrMetadataEXT* pMetadata);
|
|
|
|
#ifdef VK_USE_PLATFORM_IOS_MVK
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_IOS_MVK */
|
|
|
|
#ifdef VK_USE_PLATFORM_MACOS_MVK
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
|
|
VkInstance instance,
|
|
const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_MACOS_MVK */
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
|
|
VkDevice device,
|
|
const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
|
|
VkDevice device,
|
|
const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
|
|
VkQueue queue,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
|
|
VkQueue queue);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
|
|
VkQueue queue,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkDebugUtilsLabelEXT* pLabelInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugUtilsMessengerEXT* pMessenger);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessengerEXT messenger,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
|
|
VkInstance instance,
|
|
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
|
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
|
|
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
|
|
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
|
|
VkDevice device,
|
|
const struct AHardwareBuffer* buffer,
|
|
VkAndroidHardwareBufferPropertiesANDROID* pProperties);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
|
|
VkDevice device,
|
|
const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
|
|
struct AHardwareBuffer** pBuffer);
|
|
#endif /* VK_USE_PLATFORM_ANDROID_KHR */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkSampleCountFlagBits samples,
|
|
VkMultisamplePropertiesEXT* pMultisampleProperties);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
|
|
VkDevice device,
|
|
VkImage image,
|
|
VkImageDrmFormatModifierPropertiesEXT* pProperties);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
|
|
VkDevice device,
|
|
const VkValidationCacheCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkValidationCacheEXT* pValidationCache);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT validationCache,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT dstCache,
|
|
uint32_t srcCacheCount,
|
|
const VkValidationCacheEXT* pSrcCaches);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
|
|
VkDevice device,
|
|
VkValidationCacheEXT validationCache,
|
|
size_t* pDataSize,
|
|
void* pData);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImageView imageView,
|
|
VkImageLayout imageLayout);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstViewport,
|
|
uint32_t viewportCount,
|
|
const VkShadingRatePaletteNV* pShadingRatePalettes);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCoarseSampleOrderTypeNV sampleOrderType,
|
|
uint32_t customSampleOrderCount,
|
|
const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
|
|
VkDevice device,
|
|
const VkAccelerationStructureCreateInfoNV* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkAccelerationStructureNV* pAccelerationStructure);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
|
|
VkDevice device,
|
|
VkAccelerationStructureNV accelerationStructure,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
|
|
VkDevice device,
|
|
const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
|
|
VkMemoryRequirements2KHR* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
|
|
VkDevice device,
|
|
uint32_t bindInfoCount,
|
|
const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkAccelerationStructureInfoNV* pInfo,
|
|
VkBuffer instanceData,
|
|
VkDeviceSize instanceOffset,
|
|
VkBool32 update,
|
|
VkAccelerationStructureNV dst,
|
|
VkAccelerationStructureNV src,
|
|
VkBuffer scratch,
|
|
VkDeviceSize scratchOffset);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkAccelerationStructureNV dst,
|
|
VkAccelerationStructureNV src,
|
|
VkCopyAccelerationStructureModeKHR mode);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer raygenShaderBindingTableBuffer,
|
|
VkDeviceSize raygenShaderBindingOffset,
|
|
VkBuffer missShaderBindingTableBuffer,
|
|
VkDeviceSize missShaderBindingOffset,
|
|
VkDeviceSize missShaderBindingStride,
|
|
VkBuffer hitShaderBindingTableBuffer,
|
|
VkDeviceSize hitShaderBindingOffset,
|
|
VkDeviceSize hitShaderBindingStride,
|
|
VkBuffer callableShaderBindingTableBuffer,
|
|
VkDeviceSize callableShaderBindingOffset,
|
|
VkDeviceSize callableShaderBindingStride,
|
|
uint32_t width,
|
|
uint32_t height,
|
|
uint32_t depth);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
|
|
VkDevice device,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t firstGroup,
|
|
uint32_t groupCount,
|
|
size_t dataSize,
|
|
void* pData);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t firstGroup,
|
|
uint32_t groupCount,
|
|
size_t dataSize,
|
|
void* pData);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
|
|
VkDevice device,
|
|
VkAccelerationStructureNV accelerationStructure,
|
|
size_t dataSize,
|
|
void* pData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t accelerationStructureCount,
|
|
const VkAccelerationStructureNV* pAccelerationStructures,
|
|
VkQueryType queryType,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t shader);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
const void* pHostPointer,
|
|
VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlagBits pipelineStage,
|
|
VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset,
|
|
uint32_t marker);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pTimeDomainCount,
|
|
VkTimeDomainEXT* pTimeDomains);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
|
|
VkDevice device,
|
|
uint32_t timestampCount,
|
|
const VkCalibratedTimestampInfoEXT* pTimestampInfos,
|
|
uint64_t* pTimestamps,
|
|
uint64_t* pMaxDeviation);
|
|
|
|
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
#endif /* VK_ENABLE_BETA_EXTENSIONS */
|
|
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_GGP
|
|
#endif /* VK_USE_PLATFORM_GGP */
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t taskCount,
|
|
uint32_t firstTask);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
uint32_t drawCount,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBuffer buffer,
|
|
VkDeviceSize offset,
|
|
VkBuffer countBuffer,
|
|
VkDeviceSize countBufferOffset,
|
|
uint32_t maxDrawCount,
|
|
uint32_t stride);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstExclusiveScissor,
|
|
uint32_t exclusiveScissorCount,
|
|
const VkRect2D* pExclusiveScissors);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
|
|
VkCommandBuffer commandBuffer,
|
|
const void* pCheckpointMarker);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
|
|
VkQueue queue,
|
|
uint32_t* pCheckpointDataCount,
|
|
VkCheckpointDataNV* pCheckpointData);
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
|
|
VkDevice device,
|
|
const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
|
|
VkDevice device);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceMarkerInfoINTEL* pMarkerInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkPerformanceOverrideInfoINTEL* pOverrideInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
|
|
VkDevice device,
|
|
const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
|
|
VkPerformanceConfigurationINTEL* pConfiguration);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
|
|
VkDevice device,
|
|
VkPerformanceConfigurationINTEL configuration);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
|
|
VkQueue queue,
|
|
VkPerformanceConfigurationINTEL configuration);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
|
|
VkDevice device,
|
|
VkPerformanceParameterTypeINTEL parameter,
|
|
VkPerformanceValueINTEL* pValue);
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapChain,
|
|
VkBool32 localDimmingEnable);
|
|
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
|
|
VkInstance instance,
|
|
const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_FUCHSIA */
|
|
|
|
#ifdef VK_USE_PLATFORM_METAL_EXT
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
#endif /* VK_USE_PLATFORM_METAL_EXT */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
|
|
VkDevice device,
|
|
const VkBufferDeviceAddressInfo* pInfo);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pToolCount,
|
|
VkPhysicalDeviceToolProperties* pToolProperties);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pPropertyCount,
|
|
VkCooperativeMatrixPropertiesNV* pProperties);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t* pCombinationCount,
|
|
VkFramebufferMixedSamplesCombinationNV* pCombinations);
|
|
|
|
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
uint32_t* pPresentModeCount,
|
|
VkPresentModeKHR* pPresentModes);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
|
|
VkDevice device,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
VkDeviceGroupPresentModeFlagsKHR* pModes);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t lineStippleFactor,
|
|
uint16_t lineStipplePattern);
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
|
|
VkDevice device,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery,
|
|
uint32_t queryCount);
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCullModeFlags cullMode);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkFrontFace frontFace);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPrimitiveTopology primitiveTopology);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t viewportCount,
|
|
const VkViewport* pViewports);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t scissorCount,
|
|
const VkRect2D* pScissors);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t firstBinding,
|
|
uint32_t bindingCount,
|
|
const VkBuffer* pBuffers,
|
|
const VkDeviceSize* pOffsets,
|
|
const VkDeviceSize* pSizes,
|
|
const VkDeviceSize* pStrides);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthWriteEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkCompareOp depthCompareOp);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthBoundsTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 stencilTestEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask,
|
|
VkStencilOp failOp,
|
|
VkStencilOp passOp,
|
|
VkStencilOp depthFailOp,
|
|
VkCompareOp compareOp);
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
|
|
VkDevice device,
|
|
const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
|
|
VkMemoryRequirements2* pMemoryRequirements);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 isPreprocessed,
|
|
const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipeline pipeline,
|
|
uint32_t groupIndex);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
|
|
VkDevice device,
|
|
const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
|
|
VkDevice device,
|
|
VkIndirectCommandsLayoutNV indirectCommandsLayout,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
int32_t drmFd,
|
|
VkDisplayKHR display);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
int32_t drmFd,
|
|
uint32_t connectorId,
|
|
VkDisplayKHR* display);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(
|
|
VkDevice device,
|
|
const VkPrivateDataSlotCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPrivateDataSlot* pPrivateDataSlot);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(
|
|
VkDevice device,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(
|
|
VkDevice device,
|
|
VkObjectType objectType,
|
|
uint64_t objectHandle,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
uint64_t data);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(
|
|
VkDevice device,
|
|
VkObjectType objectType,
|
|
uint64_t objectHandle,
|
|
VkPrivateDataSlot privateDataSlot,
|
|
uint64_t* pData);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(
|
|
VkCommandBuffer commandBuffer,
|
|
VkFragmentShadingRateNV shadingRate,
|
|
const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t deviceRelativeId,
|
|
VkDisplayKHR* pDisplay);
|
|
#endif /* VK_USE_PLATFORM_WIN32_KHR */
|
|
|
|
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(
|
|
VkInstance instance,
|
|
const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
IDirectFB* dfb);
|
|
#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t vertexBindingDescriptionCount,
|
|
const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,
|
|
uint32_t vertexAttributeDescriptionCount,
|
|
const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
|
|
|
|
|
|
|
|
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
|
|
VkDevice device,
|
|
const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
|
|
zx_handle_t* pZirconHandle);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
zx_handle_t zirconHandle,
|
|
VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties);
|
|
#endif /* VK_USE_PLATFORM_FUCHSIA */
|
|
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
|
|
VkDevice device,
|
|
const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
|
|
VkDevice device,
|
|
const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
|
|
zx_handle_t* pZirconHandle);
|
|
#endif /* VK_USE_PLATFORM_FUCHSIA */
|
|
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA(
|
|
VkDevice device,
|
|
const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkBufferCollectionFUCHSIA* pCollection);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA(
|
|
VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA(
|
|
VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA(
|
|
VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA(
|
|
VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
VkBufferCollectionPropertiesFUCHSIA* pProperties);
|
|
#endif /* VK_USE_PLATFORM_FUCHSIA */
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
|
|
VkDevice device,
|
|
VkRenderPass renderpass,
|
|
VkExtent2D* pMaxWorkgroupSize);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI(
|
|
VkCommandBuffer commandBuffer);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(
|
|
VkCommandBuffer commandBuffer,
|
|
VkImageView imageView,
|
|
VkImageLayout imageLayout);
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(
|
|
VkDevice device,
|
|
const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
|
|
VkRemoteAddressNV* pAddress);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t patchControlPoints);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 rasterizerDiscardEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 depthBiasEnable);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkLogicOp logicOp);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
VkBool32 primitiveRestartEnable);
|
|
|
|
#ifdef VK_USE_PLATFORM_SCREEN_QNX
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(
|
|
VkInstance instance,
|
|
const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
struct _screen_window* window);
|
|
#endif /* VK_USE_PLATFORM_SCREEN_QNX */
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t attachmentCount,
|
|
const VkBool32* pColorWriteEnables);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t drawCount,
|
|
const VkMultiDrawInfoEXT* pVertexInfo,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
uint32_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t drawCount,
|
|
const VkMultiDrawIndexedInfoEXT* pIndexInfo,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
uint32_t stride,
|
|
const int32_t* pVertexOffset);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
float priority);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE(
|
|
VkDevice device,
|
|
const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
|
|
VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE(
|
|
VkDevice device,
|
|
VkDescriptorSet descriptorSet,
|
|
void** ppData);
|
|
|
|
|
|
|
|
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
|
|
VkDevice device,
|
|
const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkAccelerationStructureKHR* pAccelerationStructure);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
|
|
VkDevice device,
|
|
VkAccelerationStructureKHR accelerationStructure,
|
|
const VkAllocationCallbacks* pAllocator);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t infoCount,
|
|
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
|
|
const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t infoCount,
|
|
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
|
|
const VkDeviceAddress* pIndirectDeviceAddresses,
|
|
const uint32_t* pIndirectStrides,
|
|
const uint32_t* const* ppMaxPrimitiveCounts);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
uint32_t infoCount,
|
|
const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
|
|
const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
const VkCopyAccelerationStructureInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
|
|
VkDevice device,
|
|
uint32_t accelerationStructureCount,
|
|
const VkAccelerationStructureKHR* pAccelerationStructures,
|
|
VkQueryType queryType,
|
|
size_t dataSize,
|
|
void* pData,
|
|
size_t stride);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyAccelerationStructureInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
|
|
VkDevice device,
|
|
const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t accelerationStructureCount,
|
|
const VkAccelerationStructureKHR* pAccelerationStructures,
|
|
VkQueryType queryType,
|
|
VkQueryPool queryPool,
|
|
uint32_t firstQuery);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
|
|
VkDevice device,
|
|
const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
|
|
VkAccelerationStructureCompatibilityKHR* pCompatibility);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
|
|
VkDevice device,
|
|
VkAccelerationStructureBuildTypeKHR buildType,
|
|
const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
|
|
const uint32_t* pMaxPrimitiveCounts,
|
|
VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);
|
|
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
|
|
uint32_t width,
|
|
uint32_t height,
|
|
uint32_t depth);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
|
|
VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkPipeline* pPipelines);
|
|
|
|
static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t firstGroup,
|
|
uint32_t groupCount,
|
|
size_t dataSize,
|
|
void* pData);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,
|
|
VkDeviceAddress indirectDeviceAddress);
|
|
|
|
static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(
|
|
VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t group,
|
|
VkShaderGroupShaderKHR groupShader);
|
|
|
|
static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(
|
|
VkCommandBuffer commandBuffer,
|
|
uint32_t pipelineStackSize);
|
|
|
|
|
|
// Map of all APIs to be intercepted by this layer
|
|
static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
|
|
{"vkCreateInstance", (void*)CreateInstance},
|
|
{"vkDestroyInstance", (void*)DestroyInstance},
|
|
{"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
|
|
{"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
|
|
{"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
|
|
{"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
|
|
{"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
|
|
{"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
|
|
{"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
|
|
{"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
|
|
{"vkCreateDevice", (void*)CreateDevice},
|
|
{"vkDestroyDevice", (void*)DestroyDevice},
|
|
{"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
|
|
{"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
|
|
{"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
|
|
{"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
|
|
{"vkGetDeviceQueue", (void*)GetDeviceQueue},
|
|
{"vkQueueSubmit", (void*)QueueSubmit},
|
|
{"vkQueueWaitIdle", (void*)QueueWaitIdle},
|
|
{"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
|
|
{"vkAllocateMemory", (void*)AllocateMemory},
|
|
{"vkFreeMemory", (void*)FreeMemory},
|
|
{"vkMapMemory", (void*)MapMemory},
|
|
{"vkUnmapMemory", (void*)UnmapMemory},
|
|
{"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
|
|
{"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
|
|
{"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
|
|
{"vkBindBufferMemory", (void*)BindBufferMemory},
|
|
{"vkBindImageMemory", (void*)BindImageMemory},
|
|
{"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
|
|
{"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
|
|
{"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
|
|
{"vkQueueBindSparse", (void*)QueueBindSparse},
|
|
{"vkCreateFence", (void*)CreateFence},
|
|
{"vkDestroyFence", (void*)DestroyFence},
|
|
{"vkResetFences", (void*)ResetFences},
|
|
{"vkGetFenceStatus", (void*)GetFenceStatus},
|
|
{"vkWaitForFences", (void*)WaitForFences},
|
|
{"vkCreateSemaphore", (void*)CreateSemaphore},
|
|
{"vkDestroySemaphore", (void*)DestroySemaphore},
|
|
{"vkCreateEvent", (void*)CreateEvent},
|
|
{"vkDestroyEvent", (void*)DestroyEvent},
|
|
{"vkGetEventStatus", (void*)GetEventStatus},
|
|
{"vkSetEvent", (void*)SetEvent},
|
|
{"vkResetEvent", (void*)ResetEvent},
|
|
{"vkCreateQueryPool", (void*)CreateQueryPool},
|
|
{"vkDestroyQueryPool", (void*)DestroyQueryPool},
|
|
{"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
|
|
{"vkCreateBuffer", (void*)CreateBuffer},
|
|
{"vkDestroyBuffer", (void*)DestroyBuffer},
|
|
{"vkCreateBufferView", (void*)CreateBufferView},
|
|
{"vkDestroyBufferView", (void*)DestroyBufferView},
|
|
{"vkCreateImage", (void*)CreateImage},
|
|
{"vkDestroyImage", (void*)DestroyImage},
|
|
{"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
|
|
{"vkCreateImageView", (void*)CreateImageView},
|
|
{"vkDestroyImageView", (void*)DestroyImageView},
|
|
{"vkCreateShaderModule", (void*)CreateShaderModule},
|
|
{"vkDestroyShaderModule", (void*)DestroyShaderModule},
|
|
{"vkCreatePipelineCache", (void*)CreatePipelineCache},
|
|
{"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
|
|
{"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
|
|
{"vkMergePipelineCaches", (void*)MergePipelineCaches},
|
|
{"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
|
|
{"vkCreateComputePipelines", (void*)CreateComputePipelines},
|
|
{"vkDestroyPipeline", (void*)DestroyPipeline},
|
|
{"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
|
|
{"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
|
|
{"vkCreateSampler", (void*)CreateSampler},
|
|
{"vkDestroySampler", (void*)DestroySampler},
|
|
{"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
|
|
{"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
|
|
{"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
|
|
{"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
|
|
{"vkResetDescriptorPool", (void*)ResetDescriptorPool},
|
|
{"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
|
|
{"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
|
|
{"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
|
|
{"vkCreateFramebuffer", (void*)CreateFramebuffer},
|
|
{"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
|
|
{"vkCreateRenderPass", (void*)CreateRenderPass},
|
|
{"vkDestroyRenderPass", (void*)DestroyRenderPass},
|
|
{"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
|
|
{"vkCreateCommandPool", (void*)CreateCommandPool},
|
|
{"vkDestroyCommandPool", (void*)DestroyCommandPool},
|
|
{"vkResetCommandPool", (void*)ResetCommandPool},
|
|
{"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
|
|
{"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
|
|
{"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
|
|
{"vkEndCommandBuffer", (void*)EndCommandBuffer},
|
|
{"vkResetCommandBuffer", (void*)ResetCommandBuffer},
|
|
{"vkCmdBindPipeline", (void*)CmdBindPipeline},
|
|
{"vkCmdSetViewport", (void*)CmdSetViewport},
|
|
{"vkCmdSetScissor", (void*)CmdSetScissor},
|
|
{"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
|
|
{"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
|
|
{"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
|
|
{"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
|
|
{"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
|
|
{"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
|
|
{"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
|
|
{"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
|
|
{"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
|
|
{"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
|
|
{"vkCmdDraw", (void*)CmdDraw},
|
|
{"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
|
|
{"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
|
|
{"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
|
|
{"vkCmdDispatch", (void*)CmdDispatch},
|
|
{"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
|
|
{"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
|
|
{"vkCmdCopyImage", (void*)CmdCopyImage},
|
|
{"vkCmdBlitImage", (void*)CmdBlitImage},
|
|
{"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
|
|
{"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
|
|
{"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
|
|
{"vkCmdFillBuffer", (void*)CmdFillBuffer},
|
|
{"vkCmdClearColorImage", (void*)CmdClearColorImage},
|
|
{"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
|
|
{"vkCmdClearAttachments", (void*)CmdClearAttachments},
|
|
{"vkCmdResolveImage", (void*)CmdResolveImage},
|
|
{"vkCmdSetEvent", (void*)CmdSetEvent},
|
|
{"vkCmdResetEvent", (void*)CmdResetEvent},
|
|
{"vkCmdWaitEvents", (void*)CmdWaitEvents},
|
|
{"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
|
|
{"vkCmdBeginQuery", (void*)CmdBeginQuery},
|
|
{"vkCmdEndQuery", (void*)CmdEndQuery},
|
|
{"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
|
|
{"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
|
|
{"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
|
|
{"vkCmdPushConstants", (void*)CmdPushConstants},
|
|
{"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
|
|
{"vkCmdNextSubpass", (void*)CmdNextSubpass},
|
|
{"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
|
|
{"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
|
|
{"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion},
|
|
{"vkBindBufferMemory2", (void*)BindBufferMemory2},
|
|
{"vkBindImageMemory2", (void*)BindImageMemory2},
|
|
{"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures},
|
|
{"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask},
|
|
{"vkCmdDispatchBase", (void*)CmdDispatchBase},
|
|
{"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups},
|
|
{"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2},
|
|
{"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2},
|
|
{"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2},
|
|
{"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2},
|
|
{"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2},
|
|
{"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2},
|
|
{"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2},
|
|
{"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2},
|
|
{"vkTrimCommandPool", (void*)TrimCommandPool},
|
|
{"vkGetDeviceQueue2", (void*)GetDeviceQueue2},
|
|
{"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion},
|
|
{"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion},
|
|
{"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate},
|
|
{"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate},
|
|
{"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate},
|
|
{"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties},
|
|
{"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties},
|
|
{"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties},
|
|
{"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport},
|
|
{"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount},
|
|
{"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount},
|
|
{"vkCreateRenderPass2", (void*)CreateRenderPass2},
|
|
{"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2},
|
|
{"vkCmdNextSubpass2", (void*)CmdNextSubpass2},
|
|
{"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2},
|
|
{"vkResetQueryPool", (void*)ResetQueryPool},
|
|
{"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue},
|
|
{"vkWaitSemaphores", (void*)WaitSemaphores},
|
|
{"vkSignalSemaphore", (void*)SignalSemaphore},
|
|
{"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress},
|
|
{"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress},
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress},
|
|
{"vkGetPhysicalDeviceToolProperties", (void*)GetPhysicalDeviceToolProperties},
|
|
{"vkCreatePrivateDataSlot", (void*)CreatePrivateDataSlot},
|
|
{"vkDestroyPrivateDataSlot", (void*)DestroyPrivateDataSlot},
|
|
{"vkSetPrivateData", (void*)SetPrivateData},
|
|
{"vkGetPrivateData", (void*)GetPrivateData},
|
|
{"vkCmdSetEvent2", (void*)CmdSetEvent2},
|
|
{"vkCmdResetEvent2", (void*)CmdResetEvent2},
|
|
{"vkCmdWaitEvents2", (void*)CmdWaitEvents2},
|
|
{"vkCmdPipelineBarrier2", (void*)CmdPipelineBarrier2},
|
|
{"vkCmdWriteTimestamp2", (void*)CmdWriteTimestamp2},
|
|
{"vkQueueSubmit2", (void*)QueueSubmit2},
|
|
{"vkCmdCopyBuffer2", (void*)CmdCopyBuffer2},
|
|
{"vkCmdCopyImage2", (void*)CmdCopyImage2},
|
|
{"vkCmdCopyBufferToImage2", (void*)CmdCopyBufferToImage2},
|
|
{"vkCmdCopyImageToBuffer2", (void*)CmdCopyImageToBuffer2},
|
|
{"vkCmdBlitImage2", (void*)CmdBlitImage2},
|
|
{"vkCmdResolveImage2", (void*)CmdResolveImage2},
|
|
{"vkCmdBeginRendering", (void*)CmdBeginRendering},
|
|
{"vkCmdEndRendering", (void*)CmdEndRendering},
|
|
{"vkCmdSetCullMode", (void*)CmdSetCullMode},
|
|
{"vkCmdSetFrontFace", (void*)CmdSetFrontFace},
|
|
{"vkCmdSetPrimitiveTopology", (void*)CmdSetPrimitiveTopology},
|
|
{"vkCmdSetViewportWithCount", (void*)CmdSetViewportWithCount},
|
|
{"vkCmdSetScissorWithCount", (void*)CmdSetScissorWithCount},
|
|
{"vkCmdBindVertexBuffers2", (void*)CmdBindVertexBuffers2},
|
|
{"vkCmdSetDepthTestEnable", (void*)CmdSetDepthTestEnable},
|
|
{"vkCmdSetDepthWriteEnable", (void*)CmdSetDepthWriteEnable},
|
|
{"vkCmdSetDepthCompareOp", (void*)CmdSetDepthCompareOp},
|
|
{"vkCmdSetDepthBoundsTestEnable", (void*)CmdSetDepthBoundsTestEnable},
|
|
{"vkCmdSetStencilTestEnable", (void*)CmdSetStencilTestEnable},
|
|
{"vkCmdSetStencilOp", (void*)CmdSetStencilOp},
|
|
{"vkCmdSetRasterizerDiscardEnable", (void*)CmdSetRasterizerDiscardEnable},
|
|
{"vkCmdSetDepthBiasEnable", (void*)CmdSetDepthBiasEnable},
|
|
{"vkCmdSetPrimitiveRestartEnable", (void*)CmdSetPrimitiveRestartEnable},
|
|
{"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements},
|
|
{"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements},
|
|
{"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements},
|
|
{"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
|
|
{"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
|
|
{"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
|
|
{"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
|
|
{"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
|
|
{"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
|
|
{"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
|
|
{"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
|
|
{"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
|
|
{"vkQueuePresentKHR", (void*)QueuePresentKHR},
|
|
{"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR},
|
|
{"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR},
|
|
{"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR},
|
|
{"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR},
|
|
{"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR},
|
|
{"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR},
|
|
{"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
|
|
{"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
|
|
{"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
|
|
{"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
|
|
{"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
|
|
{"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
|
|
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
|
{"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_XLIB_KHR
|
|
{"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
|
{"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_XCB_KHR
|
|
{"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
|
{"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
|
|
{"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
{"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkGetPhysicalDeviceVideoCapabilitiesKHR", (void*)GetPhysicalDeviceVideoCapabilitiesKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkGetPhysicalDeviceVideoFormatPropertiesKHR", (void*)GetPhysicalDeviceVideoFormatPropertiesKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCreateVideoSessionKHR", (void*)CreateVideoSessionKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkDestroyVideoSessionKHR", (void*)DestroyVideoSessionKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkGetVideoSessionMemoryRequirementsKHR", (void*)GetVideoSessionMemoryRequirementsKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkBindVideoSessionMemoryKHR", (void*)BindVideoSessionMemoryKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCreateVideoSessionParametersKHR", (void*)CreateVideoSessionParametersKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkUpdateVideoSessionParametersKHR", (void*)UpdateVideoSessionParametersKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkDestroyVideoSessionParametersKHR", (void*)DestroyVideoSessionParametersKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCmdBeginVideoCodingKHR", (void*)CmdBeginVideoCodingKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCmdEndVideoCodingKHR", (void*)CmdEndVideoCodingKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCmdControlVideoCodingKHR", (void*)CmdControlVideoCodingKHR},
|
|
#endif
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCmdDecodeVideoKHR", (void*)CmdDecodeVideoKHR},
|
|
#endif
|
|
{"vkCmdBeginRenderingKHR", (void*)CmdBeginRenderingKHR},
|
|
{"vkCmdEndRenderingKHR", (void*)CmdEndRenderingKHR},
|
|
{"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR},
|
|
{"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR},
|
|
{"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR},
|
|
{"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR},
|
|
{"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR},
|
|
{"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR},
|
|
{"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR},
|
|
{"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR},
|
|
{"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR},
|
|
{"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR},
|
|
{"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
|
|
{"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR},
|
|
{"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
|
|
#endif
|
|
{"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
|
|
{"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
|
|
{"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
|
|
#endif
|
|
{"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
|
|
{"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
|
|
{"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
|
|
{"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
|
|
{"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
|
|
{"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
|
|
{"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
|
|
{"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR},
|
|
{"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR},
|
|
{"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR},
|
|
{"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR},
|
|
{"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
|
|
{"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
|
|
#endif
|
|
{"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
|
|
{"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
|
|
{"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
|
|
{"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
|
|
{"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR},
|
|
{"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR},
|
|
{"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
|
|
{"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
|
|
{"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR},
|
|
{"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR},
|
|
{"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR},
|
|
{"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR},
|
|
{"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
|
|
{"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
|
|
{"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
|
|
{"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR},
|
|
{"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR},
|
|
{"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR},
|
|
{"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR},
|
|
{"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR},
|
|
{"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR},
|
|
{"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR},
|
|
{"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR},
|
|
{"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR},
|
|
{"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR},
|
|
{"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR},
|
|
{"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR},
|
|
{"vkWaitForPresentKHR", (void*)WaitForPresentKHR},
|
|
{"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR},
|
|
{"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR},
|
|
{"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR},
|
|
{"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR},
|
|
{"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR},
|
|
{"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR},
|
|
{"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR},
|
|
{"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR},
|
|
{"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR},
|
|
{"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR},
|
|
{"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR},
|
|
#ifdef VK_ENABLE_BETA_EXTENSIONS
|
|
{"vkCmdEncodeVideoKHR", (void*)CmdEncodeVideoKHR},
|
|
#endif
|
|
{"vkCmdSetEvent2KHR", (void*)CmdSetEvent2KHR},
|
|
{"vkCmdResetEvent2KHR", (void*)CmdResetEvent2KHR},
|
|
{"vkCmdWaitEvents2KHR", (void*)CmdWaitEvents2KHR},
|
|
{"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR},
|
|
{"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR},
|
|
{"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR},
|
|
{"vkCmdWriteBufferMarker2AMD", (void*)CmdWriteBufferMarker2AMD},
|
|
{"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV},
|
|
{"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR},
|
|
{"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR},
|
|
{"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR},
|
|
{"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR},
|
|
{"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR},
|
|
{"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR},
|
|
{"vkGetDeviceBufferMemoryRequirementsKHR", (void*)GetDeviceBufferMemoryRequirementsKHR},
|
|
{"vkGetDeviceImageMemoryRequirementsKHR", (void*)GetDeviceImageMemoryRequirementsKHR},
|
|
{"vkGetDeviceImageSparseMemoryRequirementsKHR", (void*)GetDeviceImageSparseMemoryRequirementsKHR},
|
|
{"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
|
|
{"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
|
|
{"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
|
|
{"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT},
|
|
{"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT},
|
|
{"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT},
|
|
{"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT},
|
|
{"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT},
|
|
{"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT},
|
|
{"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT},
|
|
{"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT},
|
|
{"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT},
|
|
{"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT},
|
|
{"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT},
|
|
{"vkCreateCuModuleNVX", (void*)CreateCuModuleNVX},
|
|
{"vkCreateCuFunctionNVX", (void*)CreateCuFunctionNVX},
|
|
{"vkDestroyCuModuleNVX", (void*)DestroyCuModuleNVX},
|
|
{"vkDestroyCuFunctionNVX", (void*)DestroyCuFunctionNVX},
|
|
{"vkCmdCuLaunchKernelNVX", (void*)CmdCuLaunchKernelNVX},
|
|
{"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX},
|
|
{"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX},
|
|
{"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
|
|
{"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
|
|
{"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD},
|
|
#ifdef VK_USE_PLATFORM_GGP
|
|
{"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP},
|
|
#endif
|
|
{"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_VI_NN
|
|
{"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
|
|
#endif
|
|
{"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT},
|
|
{"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT},
|
|
{"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
|
|
{"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
|
|
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
{"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
|
|
{"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
|
|
#endif
|
|
{"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
|
|
{"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
|
|
{"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
|
|
{"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
|
|
{"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
|
|
{"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
|
|
{"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
|
|
{"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
|
|
{"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
|
|
#ifdef VK_USE_PLATFORM_IOS_MVK
|
|
{"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_MACOS_MVK
|
|
{"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
|
|
#endif
|
|
{"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT},
|
|
{"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT},
|
|
{"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT},
|
|
{"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT},
|
|
{"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT},
|
|
{"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT},
|
|
{"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT},
|
|
{"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT},
|
|
{"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT},
|
|
{"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT},
|
|
{"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT},
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
{"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_ANDROID_KHR
|
|
{"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID},
|
|
#endif
|
|
{"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT},
|
|
{"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT},
|
|
{"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT},
|
|
{"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT},
|
|
{"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT},
|
|
{"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT},
|
|
{"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT},
|
|
{"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV},
|
|
{"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV},
|
|
{"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV},
|
|
{"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV},
|
|
{"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV},
|
|
{"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV},
|
|
{"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV},
|
|
{"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV},
|
|
{"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV},
|
|
{"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV},
|
|
{"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV},
|
|
{"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR},
|
|
{"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV},
|
|
{"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV},
|
|
{"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV},
|
|
{"vkCompileDeferredNV", (void*)CompileDeferredNV},
|
|
{"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT},
|
|
{"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD},
|
|
{"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT},
|
|
{"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT},
|
|
{"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV},
|
|
{"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV},
|
|
{"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV},
|
|
{"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV},
|
|
{"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV},
|
|
{"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV},
|
|
{"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL},
|
|
{"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL},
|
|
{"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL},
|
|
{"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL},
|
|
{"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL},
|
|
{"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL},
|
|
{"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL},
|
|
{"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL},
|
|
{"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL},
|
|
{"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD},
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_METAL_EXT
|
|
{"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT},
|
|
#endif
|
|
{"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT},
|
|
{"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT},
|
|
{"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV},
|
|
{"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT},
|
|
#endif
|
|
{"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT},
|
|
{"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT},
|
|
{"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT},
|
|
{"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT},
|
|
{"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT},
|
|
{"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT},
|
|
{"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT},
|
|
{"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT},
|
|
{"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT},
|
|
{"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT},
|
|
{"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT},
|
|
{"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT},
|
|
{"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT},
|
|
{"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT},
|
|
{"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT},
|
|
{"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV},
|
|
{"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV},
|
|
{"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV},
|
|
{"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV},
|
|
{"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV},
|
|
{"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV},
|
|
{"vkAcquireDrmDisplayEXT", (void*)AcquireDrmDisplayEXT},
|
|
{"vkGetDrmDisplayEXT", (void*)GetDrmDisplayEXT},
|
|
{"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT},
|
|
{"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT},
|
|
{"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT},
|
|
{"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT},
|
|
{"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV},
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_WIN32_KHR
|
|
{"vkGetWinrtDisplayNV", (void*)GetWinrtDisplayNV},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
|
|
{"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
|
|
{"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT},
|
|
#endif
|
|
{"vkCmdSetVertexInputEXT", (void*)CmdSetVertexInputEXT},
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkSetBufferCollectionImageConstraintsFUCHSIA", (void*)SetBufferCollectionImageConstraintsFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkSetBufferCollectionBufferConstraintsFUCHSIA", (void*)SetBufferCollectionBufferConstraintsFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_FUCHSIA
|
|
{"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA},
|
|
#endif
|
|
{"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", (void*)GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI},
|
|
{"vkCmdSubpassShadingHUAWEI", (void*)CmdSubpassShadingHUAWEI},
|
|
{"vkCmdBindInvocationMaskHUAWEI", (void*)CmdBindInvocationMaskHUAWEI},
|
|
{"vkGetMemoryRemoteAddressNV", (void*)GetMemoryRemoteAddressNV},
|
|
{"vkCmdSetPatchControlPointsEXT", (void*)CmdSetPatchControlPointsEXT},
|
|
{"vkCmdSetRasterizerDiscardEnableEXT", (void*)CmdSetRasterizerDiscardEnableEXT},
|
|
{"vkCmdSetDepthBiasEnableEXT", (void*)CmdSetDepthBiasEnableEXT},
|
|
{"vkCmdSetLogicOpEXT", (void*)CmdSetLogicOpEXT},
|
|
{"vkCmdSetPrimitiveRestartEnableEXT", (void*)CmdSetPrimitiveRestartEnableEXT},
|
|
#ifdef VK_USE_PLATFORM_SCREEN_QNX
|
|
{"vkCreateScreenSurfaceQNX", (void*)CreateScreenSurfaceQNX},
|
|
#endif
|
|
#ifdef VK_USE_PLATFORM_SCREEN_QNX
|
|
{"vkGetPhysicalDeviceScreenPresentationSupportQNX", (void*)GetPhysicalDeviceScreenPresentationSupportQNX},
|
|
#endif
|
|
{"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT},
|
|
{"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT},
|
|
{"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT},
|
|
{"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT},
|
|
{"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE},
|
|
{"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE},
|
|
{"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR},
|
|
{"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR},
|
|
{"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR},
|
|
{"vkCmdBuildAccelerationStructuresIndirectKHR", (void*)CmdBuildAccelerationStructuresIndirectKHR},
|
|
{"vkBuildAccelerationStructuresKHR", (void*)BuildAccelerationStructuresKHR},
|
|
{"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR},
|
|
{"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR},
|
|
{"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR},
|
|
{"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR},
|
|
{"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR},
|
|
{"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR},
|
|
{"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR},
|
|
{"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR},
|
|
{"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR},
|
|
{"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR},
|
|
{"vkGetAccelerationStructureBuildSizesKHR", (void*)GetAccelerationStructureBuildSizesKHR},
|
|
{"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR},
|
|
{"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR},
|
|
{"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR},
|
|
{"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR},
|
|
{"vkGetRayTracingShaderGroupStackSizeKHR", (void*)GetRayTracingShaderGroupStackSizeKHR},
|
|
{"vkCmdSetRayTracingPipelineStackSizeKHR", (void*)CmdSetRayTracingPipelineStackSizeKHR},
|
|
};
|
|
|
|
|
|
} // namespace vkmock
|
|
|
|
#endif
|