Как установить vulcan api на windows 10

This page provides links to both Vulkan 1.3 general release drivers, and developer beta drivers.

Vulkan 1.3 General Release Driver Downloads

Vulkan 1.3, including support for the Vulkan Ray Tracing extensions, is available for Windows and Linux in our general release drivers here:

Windows

• Download for Windows 10/11

Linux

• Download for Linux 64-bit

NVIDIA SHIELD TV

• Vulkan 1.1 on Android

Vulkan Beta Driver Downloads

Windows driver version 528.50 and Linux driver version 525.47.07 contain newly released Vulkan features and bug fixes for Vulkan developers.

Windows 528.50

• Download for Windows 10/11

Linux 525.47.07

• Download for Linux 64-bit

Vulkan Beta Driver Release Notes

The latest Vulkan 1.3 specification can be found here: https://www.khronos.org/registry/vulkan/

NVIDIA provides full Vulkan 1.3 support and functionality on NVIDIA GeForce and Quadro graphics card with one of the following Ada Lovelace, Ampere, Turing, Volta, Pascal and Maxwell (first and second generation) based GPUs:

Ada Lovelace GPU Architecture

• GeForce RTX: GeForce RTX 4090, GeForce RTX 4080, GeForce 4070 Ti

Ampere GPU Architecture

• GeForce RTX: GeForce RTX 3090, GeForce RTX 3080 Ti, GeForce RTX 3080, GeForce RTX 3070 Ti, GeForce RTX 3070, GeForce RTX 3060 Ti, GeForce RTX 3060
• NVIDIA RTX: NVIDIA RTX A6000, NVIDIA RTX A5000, NVIDIA RTX A4000, NVIDIA RTX A2000

Turing GPU Architecture

GPUs starting with the Turing family expose several Vulkan extensions giving developers access to advanced features like ray tracing, mesh shaders, variable rate shading and texture-space shading.

• TITAN: NVIDIA TITAN RTX
• GeForce RTX: GeForce RTX 2080 Ti, GeForce RTX 2080 SUPER, GeForce RTX 2080, GeForce RTX 2070 SUPER, GeForce RTX 2070, GeForce RTX 2060 SUPER, GeForce RTX 2060
• GeForce GTX: GeForce GTX 1660 Ti, GeForce GTX 1660 SUPER, GeForce GTX 1660, GeForce GTX 1650 SUPER, GeForce GTX 1650 Ti, GeForce GTX 1650, GeForce MX250, GeForce MX230
• Quadro: Quadro RTX 8000, Quadro RTX 6000, Quadro RTX 5000, Quadro RTX 4000, Quadro RTX 3000, Quadro T2000, Quadro T1000

Volta GPU Architecture

• TITAN: NVIDIA TITAN V
• Quadro: Quadro GV100

Pascal GPU Architecture

• TITAN: NVIDIA TITAN Xp, NVIDIA TITAN X (Pascal)
• GeForce: GeForce GTX 1080 Ti, GeForce GTX 1080, GeForce GTX 1070 Ti, GeForce GTX 1070, GeForce GTX 1060, GeForce GTX 1050 Ti, GeForce GTX 1050, GeForce GT 1030, GeForce MX150,
• Quadro: Quadro GP100, Quadro P6000, Quadro P5200, Quadro P5000, Quadro P4200, Quadro P4000, Quadro P3200, Quadro P3000, Quadro P2200, Quadro P2000, Quadro P1000, Quadro P620, Quadro P600, Quadro P520, Quadro P500, Quadro P400

Maxwell 2 GPU Architecture

• TITAN: GeForce GTX TITAN X
• GeForce: GeForce GTX 980 Ti, GeForce GTX 980, GeForce GTX 980M, GeForce GTX 970, GeForce GTX 970M, GeForce GTX 965M, GeForce GTX 960, GeForce GTX 950,
• Quadro: Quadro M6000 24GB, Quadro M6000, Quadro M5500, Quadro M5000, Quadro M5000M, Quadro M4000, Quadro M4000M, Quadro M3000M, Quadro M2200, Quadro M2000

Maxwell 1 GPU Architecture

• GeForce: GeForce GTX 960M, GeForce GTX 950M, GeForce 945M, GeForce 940MX, GeForce 930MX, GeForce 920MX, GeForce 940M, GeForce 930M, GeForce GTX 860M, GeForce GTX 850M, GeForce 845M, GeForce 840M, GeForce 830M, GeForce GTX 750 Ti, GeForce GTX 750, GeForce GTX 745, GeForce MX130
• Quadro: Quadro M2000M, Quadro M1000M, Quadro M600M, Quadro M500M, Quadro M1200, Quadro M620, Quadro M520, Quadro K2200M, Quadro K620M

For any bugs or issues, please file a bug through the developer website: https://devtalk.nvidia.com/

Vulkan Beta Driver Release Updates

February 3rd, 2023 — Windows 528.50, Linux 525.47.07

• New:
  • VK_EXT_pipeline_library_group_handles
• Vulkan Video driver experiments:
  • Internally synchronize the picture VkVideoSessionParametersKHR while during parameter updates with vkUpdateVideoSessionParametersKHR
  • Allow for Picture Parameters like StdVideoH264PictureParameterSet, StdVideoH264SequenceParameterSet, StdVideoH265SequenceParameterSet, StdVideoH265PictureParameterSet and StdVideoH265VideoParameterSet to be optionally passed within vkCmdBeginVideoCodingKHR() and/or vkCmdDecodeVideoKHR() within VkVideoSessionParametersUpdateInfoKHR as an inlined extension structure
• Fixes:
  • Ignore VkPipelineColorBlendStateCreateInfo.pAttachments when all state is dynamic
  • Fix an issue with the video session picture parameters creation where the max PPS/SPS/VPS size is set to 1
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/525.47.07

January 23rd, 2023 — Windows 528.34, Linux 525.47.06

• New:
  • Support for all remaining VK_EXT_extended_dynamic_state3 states:
    • VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT
    • VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT
    • VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT
    • VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT
    • VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT
    • VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT
    • VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT
    • VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT
    • VK_DYNAMIC_STATE_SAMPLE_MASK_EXT
    • VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV
    • VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV
    • VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV
    • VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV
    • VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV
    • VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV
    • VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV
    • VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV
    • VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV
    • VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV
    • VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT
• Fixes:
  • Fixed the supported 444 format reporting based on the h.265 video profiles for Maxwell and Pascal GPUs
  • Allow the use of VkVideoEncodeUsageInfoKHR and VkVideoDecodeUsageInfoKHR to be chained to VkVideoProfileInfoKHR structure
  • Handle error with video surfaces incorrectly created without the proper video usage flags
  • Handle the conditions for requiring VkVideoEncodeH264RateControlInfoEXT per the Vulkan spec VUID-VkVideoCodingControlInfoKHR-flags-07021
  • Handle the use of SPS/PPS scaling_matrix_present_flags more appropriately
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/525.47.06

December 19th, 2022 — Windows 527.86, Linux 525.47.04

• New:
  • Support for NVIDIA Ada Lovelace Architecture GPUs
  • Support for Vulkan Video 1.0
    • VK_KHR_video_queue
    • VK_KHR_video_decode_queue
    • VK_KHR_video_decode_h264
    • VK_KHR_video_decode_h265
  • VK_EXT_opacity_micromap
  • VK_NV_copy_memory_indirect
  • VK_NV_memory_decompression
  • VK_NV_optical_flow
  • VK_NV_ray_tracing_invocation_reorder
• Fixes:
  • Fixed a bug where usage of VK_KHR_present_id could cause applications to crash with Xid 32 errors [Linux]
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/525.47.04

November 17th, 2022 — Windows 517.83, Linux 515.49.25

• New:
  • VK_EXT_descriptor_buffer
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.25

October 25th, 2022 — Windows 517.69, Linux 515.49.24

• Fixes:
  • Miscellaneous Vulkan video fixes
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.24

September 30th, 2022 — Windows 517.57, Linux 515.49.19

• New:
  • VK_EXT_extended_dynamic_state3 support for the following dynamic states:
    • VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT
    • VK_DYNAMIC_STATE_POLYGON_MODE_EXT
    • VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT
    • VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT
    • VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT
    • VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT
    • VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT
    • VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT
    • VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT
    • VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT
    • VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT
  • Provisional Vulkan video extension updates:
    • VK_KHR_video_queue: 6 -> 7
    • Note: these changes are not backwards compatible with the old revisions so applications using the old revisions will need to be updated to continue working
• Fixes:
  • Fixed regression with mesh shader queries
  • Updated OpEmitMeshTasksEXT to be interpreted as a terminator instruction
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.19

September 27th, 2022 — Windows 517.55, Linux 515.49.18

• New:
  • VK_EXT_mutable_descriptor_type
  • VK_EXT_depth_clamp_zero_one
  • Provisional Vulkan video extension updates:
    • VK_KHR_video_queue: 4 -> 6
    • VK_KHR_video_decode_queue: 4 -> 6
    • VK_KHR_video_encode_queue: 5 -> 7
    • VK_EXT_video_decode_h264: 5 -> 7
    • VK_EXT_video_decode_h265: 3 -> 5
    • VK_EXT_video_encode_h264: 7 -> 9
    • Note: these changes are not backwards compatible with the old revisions so applications using the old revisions will need to be updated to continue working
• Fixes:
  • Fixed possible multi-threaded pipeline creation stall when VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT is used
  • Fixed support for image load/store/atomics with linear images
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.18

September 1st, 2022 — Windows 517.22, Linux 515.49.15

• New:
  • VK_EXT_mesh_shader
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.15

August 23rd, 2022 — Windows 517.17, Linux 515.49.14

• New:
  • VK_EXT_attachment_feedback_loop_layout
  • Added support for chaining VkShaderModuleCreateInfo when creating compute and ray tracing pipelines
• Fixes:
  • Don’t read pipeline state when it’s not valid for the pipeline library stage
  • Fixed issue clearing 3D depth images where the end slice(s) weren’t cleared completely
  • Fixed an issue where Vulkan applications would crash when running under Wayland
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.14

July 20th, 2022 — Windows 516.89, Linux 515.49.10

• New:
  • VK_EXT_pipeline_robustness
• Fixes:
  • Restored old shader disk cache behavior to remain enabled even if the app uses its own pipeline cache
  • Fixed issue with optimized graphics pipeline library final link using the wrong shaders
  • Fixed issue with some fp16 shader operations
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.10

July 2nd, 2022 — Windows 516.63, Linux 515.49.06

• New:
  • VK_EXT_shader_module_identifier
• Fixes:
  • Fixed issue with image copy when one of the formats is a single-plane interleaved video format
  • Fixed issue with vkCmdResetEvent on compute queues
  • Fixed regression with tessellation mode set be the tessellation control shader
  • Fixed issue with underestimate conservative rasterization sometimes not working correctly
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.06

June 17th, 2022 — Windows 516.48, Linux 515.49.05

• New:
  • VK_EXT_image_drm_format_modifier [Linux]
  • VK_EXT_non_seamless_cube_map
• Fixes:
  • Fix the depth and stencil clear color for dynamic rendering
  • Fix possible corruption when the shading rate image is changed
• open-gpu-kernel-modules release:
  • https://github.com/NVIDIA/open-gpu-kernel-modules/releases/tag/515.49.05

May 24th, 2022 — Windows 473.64, Linux 470.62.30

• New:
  • VK_KHR_fragment_shader_barycentric

May 10th, 2022 — Windows 473.60, Linux 470.62.29

• New:
  • VK_KHR_ray_tracing_maintenance1

April 29th, 2022 — Windows 473.50, Linux 470.62.28

• New:
  • VK_EXT_image_2d_view_of_3d
  • Updates for the latest Vulkan video extensions revisions:
    • VK_KHR_video_queue: 2 -> 3
    • VK_KHR_video_decode_queue: 2 -> 4
    • VK_KHR_video_encode_queue: 3 -> 5
    • VK_EXT_video_decode_h264: 3 -> 5
    • VK_EXT_video_decode_h265: 1 -> 3
    • VK_EXT_video_encode_h264: 3 -> 7
    • Note: these changes are not backwards compatible with the old revisions so applications using the old revisions will need to be updated to continue working
    • vk_video_samples has been updated to the new API
• Fixes:
  • Fix Optimus layer vkEnumeratePhysicalDevices to not overwrite past the end of the application’s pPhysicalDevices array
  • Fix mesh shaders and VK_EXT_graphics_pipeline_library
  • Fix pipeline caching issue with VK_EXT_graphics_pipeline_library and VkPipelineShaderStageModuleIdentifierCreateInfoEXT
  • Fix driver crash when starting a render pass with a VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT depth attachment without VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT info
  • Fix linear render targets when they are very small
  • Fix bug with vkCmdSetCullMode not applying when VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY is used

March 29th, 2022 — Windows 473.33, Linux 470.62.26

• New:
  • VK_EXT_graphics_pipeline_library
  • VK_EXT_primitives_generated_query

January 25th, 2022 — Windows 473.11, Linux 470.62.22

• New:
  • Fully conformant Vulkan 1.3 implementation
  • Includes full support for Roadmap 2022
  • VK_KHR_global_priority

January 20th, 2022 — Windows 473.07, Linux 470.62.20

• New:
  • VK_NV_linear_color_attachment
  • Support revision 1.2.203 of the Vulkan API headers, which has some minor changes to the Vulkan Video API
• Fixes:
  • Fixed vertexStrideDynamic with VK_NV_device_generated_commands (for real this time)
  • Fixed a compiler bug where an optimization pass could generate invalid accesses

December 7th, 2021 — Windows 472.85, Linux 470.62.16

• Fixes:
  • Fixed Vulkan Video encode bitstream size and RESULT_WITH_STATUS_BIT_KHR query reporting
  • Fixed VK_IMAGE_CREATE_EXTENDED_USAGE_BIT with vkGetPhysicalDeviceImageFormatProperties
  • Fixed vertexStrideDynamic with VK_NV_device_generated_commands

November 24th, 2021 — Windows 472.77, Linux 470.62.13

• New:
  • VK_EXT_depth_clip_control
• Fixes:
  • Fixed some unset VkVideoDecodeH264CapabilitiesEXT query fields
  • Fixed VK_TIME_DOMAIN_DEVICE_EXT query on SLI platforms

November 17th, 2021 — Windows 472.69, Linux 470.62.12

• New:
  • VK_EXT_border_color_swizzle
  • VK_EXT_image_view_min_lod
  • Vulkan Video APIs updated to 1.2.199
    • Updated Vulkan Video Capabilities according to the new Video spec
• Fixes:
  • Fix for 64-bit atomics not working under some conditions
  • Handle VkRenderingFragmentShadingRateAttachmentInfoKHR.imageView with a VK_NULL_HANDLE correctly

November 2nd, 2021 — Windows 472.55, Linux 470.62.07

• New:
  • VK_KHR_dynamic_rendering
  • Added support for bufferDeviceAddressCaptureReplay [Linux]
• Fixes:
  • Fixed a regression which prevented DisplayPort and HDMI 2.1 variable refresh rate (VRR) G-SYNC Compatible monitors from functioning correctly in variable refresh rate mode, resulting in issues such as flickering [Linux]
  • Optimized the Vulkan fullscreen presentation path for X11 and direct-to-display swapchains [Linux]
  • Fixed a compiler bug with Ray Tracing shaders which could cause shader execution timeouts, resulting in device loss
  • Treat video encode VUI parameters as optional to avoid driver crash when they are omitted, which is valid usage

October 6th, 2021 — Windows 472.33, Linux 470.62.05

• New:
  • VK_KHR_format_feature_flags2
  • VK_KHR_maintenance4
  • Vulkan video updates:
    • Update the VK_KHR_video_queue implementation to properly support VK_QUERY_TYPE_RESULT_STATUS_ONLY video queries
    • Improve the support for VK_KHR_video_decode_queue out-of-order parallel command buffer recording for the video decode operations
• Fixes:
  • Fixed issue with vkCmdBindDescriptorSets and unreferenced dynamic UBO/SSBO descriptors
  • Fixed issue with FragCoord and Centroid qualifier
  • Fixed an issue where unreferenced descriptor bindings were sometimes not ignored properly
  • Fixed a bug where VK_NVX_binary_import was advertised as supported on unsupported platforms which caused calls to vkCreateDevice to fail if applications attempted to enable VK_NVX_binary_import on such platforms

September 7th, 2021 — Windows 472.02, Linux 470.62.02

• New:
  • VK_KHR_shader_integer_dot_product
  • VK_EXT_direct_mode_display [Windows]
  • VK_EXT_load_store_op_none
  • VK_EXT_pageable_device_local_memory [Windows]
  • VK_EXT_primitive_topology_list_restart
• Fixes:
  • Fixed issue with vertex shader interpolation qualifiers of unused input attributes
  • Fixed issue with host-visible device local memory and capture/replay
  • Fixed issue accessing individual components of barycentric inputs

August 6th, 2021 — Windows 471.69, Linux 470.56.05

• New:
  • VK_KHR_present_id
  • VK_KHR_present_wait
  • VK_KHR_shader_subgroup_uniform_control_flow
  • VK_EXT_global_priority_query
  • VK_EXT_multi_draw
  • VK_EXT_physical_device_drm [Linux]
  • VK_EXT_queue_family_foreign
  • VK_NV_ray_tracing_motion_blur

May 13th, 2021 — Windows 458.36, Linux 455.50.19

• New:
  • VK_EXT_provoking_vertex
• Fixes:
  • Added support for Vulkan provisional video session picture parameters objects

April 19th, 2021 — Windows 458.20, Linux 455.50.14

• New:
  • VK_EXT_extended_dynamic_state2

April 13th, 2021 — Windows 458.17, Linux 455.50.12

• New:
  • Provisional Vulkan Video extensions:
    • An introduction to Vulkan Video
    • Vulkan Video sample
    • VK_KHR_video_queue
    • VK_KHR_video_decode_queue
    • VK_KHR_video_encode_queue
    • VK_EXT_video_decode_h264
    • VK_EXT_video_decode_h265
    • VK_EXT_video_encode_h264
    • VK_NV_video_queue
  • VK_EXT_color_write_enable
  • VK_EXT_vertex_input_dynamic_state
  • VK_EXT_ycbcr_2plane_444_formats
  • VK_NV_inherited_viewport_scissor

March 4th, 2021 — Windows 458.06, Linux 455.50.10

• Fixes:
  • Fixed an issue with vkCmdSetViewport when firstViewport is non-zero
  • Fixed a memory fault when using some smaller dimensions of sparse images
  • Fixed an issue where vkCreate{Graphics,Compute}Pipeline would sometimes crash when the shaders contained resources with no set/binding
  • Fixed corruption that sometimes occured with shadow rendering with image arrays
  • Fixed a bug with the host-visible device-local memory heap, where if an allocation failed due to space constraints, it could cause the application to crash on future Vulkan function calls
  • Fixed a potential crash when clearing images with multiple layers
  • Fixed a bug where using ray tracing extensions on multi-GPU setups could result in application instability if the GPUs did not match [Linux]
  • Fixed a bug where vkCreateSwapchain could cause the X Server to crash when an invalid imageFormat was provided [Linux]

February 15th, 2021 — Windows 457.96, Linux 455.50.07

• New:
  • VK_KHR_synchronization2
• Fixes:
  • Fixed handling of VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT for variable size descriptor bindings
  • Fixed the present tearing that occured in some situations [Windows]

February 2nd, 2021 — Windows 457.91, Linux 455.50.05

• Fixes:
  • Fixed bug with indexed ray payloads
  • Fixed a bug where calls to vkCreateDevice could fail on Ampere GPUs when ray tracing extensions were enabled and the application was running within the Steam Linux Runtime [Linux]

January 27th, 2021 — Windows 457.88, Linux 455.50.04

• Fixes:
  • Fixed a bug in a stencil-buffer optimization that could occasionally result in VK_ERROR_DEVICE_LOST

January 25th, 2021 — Windows 457.84, Linux 455.50.03

• New:
  • VK_KHR_workgroup_memory_explicit_layout
  • VK_KHR_zero_initialize_workgroup_memory

January 19th, 2021 — Windows 457.83, Linux 455.50.02

• New:
  • Support for linear images in host-visible video memory
• Fixes:
  • Fixed a crash Vulkan swapchain initialization on older versions of Windows 10 [Windows]
  • Fixed VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT semaphore export support [Windows]
  • Fixed an issue with OpenGL where imported Vulkan buffers would fail with GL_OUT_OF_MEMORY when marked as resident [Linux]

December 16th, 2020 — Windows 457.67, Linux 455.46.04

• New:
  • VK_NV_acquire_winrt_display [Windows]
• Fixes:
  • Fixed a crash from vkCreateGraphicsPipelines when certain blend operations were used with scalar outputs from the fragment shader
  • Fixed the X driver’s composition pipeline (used, e.g., for X desktop rotation, «ForceCompositionPipeline», and some OpenGL Swap Group configurations) to correctly preserve color precision in depth 30 [Linux]

November 23rd, 2020 — Windows 457.44, Linux 455.46.02

• New:
  • The official release of Khronos Vulkan Ray Tracing for Pascal 6GB GPUs and above:
    • VK_KHR_acceleration_structure
    • VK_KHR_ray_tracing_pipeline
    • VK_KHR_ray_query [RTX GPUs]
    • VK_KHR_pipeline_library
    • VK_KHR_deferred_host_operations
    • SPV_KHR_ray_tracing
    • SPV_KHR_ray_query [RTX GPUs]
    • GLSL_EXT_ray_tracing
    • GLSL_EXT_ray_query [RTX GPUs]
    • GLSL_EXT_ray_flags_primitive_culling
    • For Vulkan Ray Tracing samples and tutorials see https://github.com/nvpro-samples/vk_raytracing_tutorial_KHR

November 11th, 2020 — Windows 457.33, Linux 455.46.01

• New:
  • VK_NV_fragment_shading_rate_enums
• Fixes:
  • Perform fragment depth value clamping to [0,1] when the application doesn’t enable VK_EXT_depth_range_unrestricted

November 2nd, 2020 — Windows 457.17, Linux 455.34.01

• New:
  • NVIDIA GeForce RTX 3070 support
• Fixes:
  • Fixed an issue with VK_ACCESS_MEMORY_{READ,WRITE}_BITs when used as part of a render pass
  • Fixed an issue where Vulkan applications would fail to initialize if the connected X11 Server did not expose support for GLX [Linux]

October 20th, 2020 — Windows 457.00, Linux 455.26.02

• New:
  • VK_KHR_fragment_shading_rate
  • VK_KHR_shader_terminate_invocation

October 9th, 2020 — Windows 456.80, Linux 455.26.01

• Fixes:
  • Reduce host memory consumption for descriptor memory when VkDescriptorSetVariableDescriptorCountAllocateInfo is used
  • Handle SPIR-V 1.4 non-Input/Ouput entry point variables correctly
  • Fixed a blending optimization that sometimes produced an incorrect result
  • Fixed SPIR-V intersection shader compilation issue when multi entry point ray tracing modules are used

September 29th, 2020 — Windows 456.62, Linux 455.22.04

• New:
  • Rebased to r455 driver branch, which adds Ampere GPU family support
  • VK_EXT_global_priority support for Windows 10 with hardware scheduling enabled
    • Application needs to have the SeIncreaseBasePriorityPrivilege enabled to get higher priorities
  • VK_EXT_shader_image_atomic_int64
  • VK_KHR_copy_commands2
  • Allow importing external host memory as cached
• Fixes:
  • Fixed a bug in a barrier optimization that allowed some back-to-back copies to run unordered

September 9th, 2020 — Windows 452.28, Linux 450.56.11

• Fixes:
  • Fixed a bug in a SPIR-V optimization that may cause conditional blocks to not execute
  • Fixed a bug where calls to vkGetRandROutputDisplayEXT with unexpected inputs would generate X11 protocol errors [Linux]

August 7th, 2020 — Windows 451.98, Linux 450.56.06

• New:
  • VK_EXT_4444_formats

July 20th, 2020 — Windows 451.79, Linux 450.56.02

• New:
  • VK_EXT_image_robustness
  • VK_EXT_shader_atomic_float
• Fixes:
  • Fixed flipping behavior of X11 swapchains that have more than 2 images [Linux]

July 9th, 2020 — Windows 451.74, Linux 450.56.01

• New:
  • Rebased beta driver to r450 driver release branch
  • Added support for the VkPhysicalDeviceRayTracingFeaturesKHR.rayTracingIndirectTraceRays ray tracing feature
  • VK_NV_device_diagnostics_config
• Fixes:
  • Make the pSizes parameters of vkCmdBindVertexBuffers2EXT be relative to the pBuffers+pOffsets
  • Fixed potential crash in the first vkQueuePresentKHR() call after creating a new VkSwapchainKHR with a non-NULL oldSwapchain
  • Fixed potential crash in vkCmdBeginRenderPass() when using VK_EXT_sample_locations

June 23rd, 2020 — Windows 443.41, Linux 440.66.17

• New:
  • VK_EXT_extended_dynamic_state
  • VK_EXT_external_memory_host [Linux]
• Fixes:
  • Improved performance of vkCmdMultiDraw*IndirectCount on Pascal and earlier GPUs

May 26th, 2020 — Windows 443.24, Linux 440.66.15

• Fixes:
  • Fixed 16-bit SMin/SMax
  • CPU performance improvements for VkFence creation and usage [Linux]
  • Fixed a bug where vkUpdateDescriptorSetWithTemplate would ignore the stride parameter for some VkDescriptorType values
  • Fixed an issue with the Optimus layer selecting the iGPU when there was an application profile with Auto-select as the preferred graphics processor [Windows]
  • Fixed layout of compute shader shared memory that may have resulted in a compiler crash
  • Fixed a bug where vkCreateSampler would fail with no borderColor data, even though it wasn’t needed
  • Fixed a compiler issue processing image operation with extra unused coordinate operand components

  Fixed writing to dynamically indexed vec2 and vec3 fragment color outputs

May 11th, 2020 — Windows 443.15, Linux 440.66.14

• New:
  • Added support for the VkPhysicalDeviceRayTracingFeaturesKHR.rayTracingPrimitiveCulling ray tracing feature
• Fixes:
  • Fixed the returned pCheckpointDataCount value for vkGetQueueCheckpointDataNV when there are less than the requested values
  • Process the VkTimelineSemaphoreSubmitInfo structure correctly for vkQueueBindSparse
  • Fixed vec3 immediate indexing in ray tracing shaders

May the 4th, 2020 — Windows 443.09, Linux 440.66.12

• New:
  • VK_EXT_custom_border_color
  • VK_EXT_private_data
  • VK_EXT_robustness2
• Fixes:
  • Fixed a visual glitch with Vulkan applications when falling out of flipping on certain desktops such as GNOME [Linux]

April 24th, 2020 — Linux 440.66.11

• Fixes:
  • Fixed several synchronization bugs that could momentarily lock up the X server when moving/resizing/focusing OpenGL and Vulkan windows when PRIME Sync is enabled [Linux]
  • Fixed a bug which caused horizontal lines to corrupt full screen Vulkan applications [Linux]

April 18th, 2020 — Windows 442.98, Linux 440.66.09

• New:
  • Added support for more acceleration structure vertex formats
• Fixes:
  • Fixed some VkPhysicalDeviceRayTracingFeaturesKHR to be advertised correctly for the current GPU
  • Fixed potential crash when pipeline pInputAssemblyState is NULL for mesh shaders
  • Fixed memory alignment and type for ray tracing scratch memory
  • Fixed some issues with ray tracing queries
  • Fixed an issue with ray tracing pipeline creating with pipeline libraries
  • Fixed some window state transitions when using HDR [Windows]

April 2nd, 2020 — Windows 442.88, Linux 440.66.08

• New:
  • Added beta support for Ray Queries
    • VkPhysicalDeviceRayTracingFeaturesKHR.rayQuery is now VK_TRUE
    • SPIR-V: SPV_KHR_ray_query
    • GLSL: GLSL_EXT_ray_query
• Fixes:
  • Improve performance of large host-visible VkDeviceMemory allocations
  • Fixed YCbCr copy of multi-plane images

April 1st, 2020 — Windows 442.86, Linux 440.66.07

• New:
  • Multi thread-capable deferred ray tracing pipeline creation
  • Allow presenting from queue families which only expose VK_QUEUE_COMPUTE_BIT when using XCB in addition to Xlib surfaces [Linux]
• Fixes:
  • Added a workaround for Linux Steam Play title DOOM Eternal, which overrides application requested memory locations, to ensure performance-critical resources be placed in video memory [Linux]
  • Correctly cap the drawCount for vkCmdDrawIndirectCount and vkCmdDrawIndexedIndirectCount on Turing GPUs
  • Fixed descriptor indexing with large arrays and large blocks

March 24th, 2020 — Windows 442.81, Linux 440.66.04

• Fixes:
  • Fixed handling of offsets in VkAccelerationStructureBuildOffsetInfoKHR
  • Fixed a bug which could cause DXVK applications to crash when running on Optimus laptops [Windows]

March 19th, 2020 — Windows 442.77, Linux 440.66.03

• Fixed:
  • Fix for geometry flags in VK_KHR_ray_tracing

March 17th, 2020 — Windows 442.75, Linux 440.66.02

• New:
  • Multi-vendor Vulkan ray tracing
    • VK_KHR_ray_tracing
    • VK_KHR_deferred_host_operations
    • VK_KHR_pipeline_library
    • For details see the Ray Tracing in Vulkan blog post
  • VK_EXT_pipeline_creation_cache_control
  • VK_NV_device_generated_commands
    • For details see the new device generated command technical blog
    • Replaces the now deprecated VK_NVX_device_generated_commands
  • Added support for a new device-local VkMemoryType which is host-coherent and host-visible
• Fixes:
  • Fixes for HDR presentation on Windows

February 19th, 2020 — Linux 440.58.02

• Fixed:
  • Fixed a regression which added syntax errors into the default application profiles configuration file [Linux]

February 15th, 2020 — Windows 442.36, Linux 440.58.01

• New:
  • VK_KHR_shader_non_semantic_info
  • VK_EXT_tooling_info
• Fixed:
  • Fixed a regression which caused some Vulkan titles to crash on swapchain
    recreation. This was known to affect the following Vulkan titles [Linux]:
    • F1 2017
    • Rise of the Tomb Raider
    • DiRT 4
  • Fixed a visual glitch of Vulkan applications when falling out of flipping (such as when doing alt-tab) [Linux]
    • We are still investigating a glitch that reproduces with the GNOME desktop

January 15th, 2020 — Windows 441.99, Linux 440.48.02

• New:
  • Vulkan 1.2 passing vulkan-cts-1.2.1.0 conformance
    • Full Vulkan 1.2 support including timeline semaphores, descriptor indexing, buffer device address and SPIR-V 1.5
  • Add PRIME Synchronization support for Linux kernel 5.4 and newer

January 8th, 2020 — Windows 441.97, Linux 440.43.02

• Fixes:
  • Fixed a bug that caused DXVK titles to endlessly loop during shader compilation if no OpSource instruction was present
  • Fixed a build failure «fatal error: drm/drmP.h: No such file or directory» when building for Linux 5.5 release candidates
  • Other minor fixes

December 11th, 2019 — Windows 441.71, Linux 440.43.01

• New:
  • Rebased Vulkan beta driver to r440 release branch
• Fixes:
  • Fix rendering to 3D depth/stencil image slices
  • Improvements to Vulkan driver startup time
  • Fixed various resource leaks

November 25th, 2019 — Windows 436.65, Linux 435.27.08

• New:
  • VK_KHR_buffer_device_address

November 14th, 2019 — Linux 435.27.07

• Fixes:
  • Fixed a bug that caused graphical corruption, reducing visibility in caves, in Steam Play title Assassin’s Creed: Odyssey
  • Fixed a bug that caused applications running directly on a display (such as VR HMDs) to tear when a G-SYNC or G-SYNC Compatible monitor is plugged in the system

November 13th, 2019 — Windows 436.64, Linux 435.27.06

• Fixes:
  • Fixed memory leak after destroying ray tracing pipeline
  • Improved responsiveness of X11 driver when ‘NVIDIA: Wait for channel idle timed out’ messages occur
  • Improved Windows fullscreen exclusive support for non-primary monitors
  • Improved Windows G-Sync support for borderless windows
  • Further improvements when system is under low-memory stress on Windows

November 4th, 2019 — Windows 436.61, Linux 435.27.03

• New:
  • VK_KHR_separate_depth_stencil_layouts
• Fixes:
  • Improved behavior in low-memory situations
  • Fixed graphical corruption in Vulkan game F12017
  • Various minor performance improvements
  • Improved Vulkan HDR support for multi-device configurations

October 25th, 2019 — Windows 436.59, Linux 435.27.02

• New:
  • Added HDR10 passthrough presentation format and color space for Windows 10 RS2+
    • VkFormat — VK_FORMAT_A2B10G10R10_UNORM_PACK32
    • VkColorSpaceKHR — VK_COLOR_SPACE_HDR10_ST2084_EXT
  • Added support for the __GL_SYNC_DISPLAY_DEVICE environment variable for Linux Vulkan applications
• Fixes:
  • Improved bounds checking and stability for some content
  • Improved unused memory reclamation when running low on system memory for Linux
  • General performance improvements

October 13th, 2019 — Windows 436.56, Linux 435.27.01

• New:
  • VK_KHR_spirv_1_4
• Fixes:
  • Fix tearing with mailbox present mode on Windows 10 laptops and SLI platforms

October 7th, 2019 — Windows 436.52, Linux 435.27.00

• New:
  • VK_KHR_shader_clock
  • VK_KHR_timeline_semaphore

September 18th, 2019 — Windows 436.39, Linux 435.24.02

• New:
  • VK_KHR_shader_subgroup_extended_types
• Fixes:
  • Fixed a regression introduced in 435.19.02 that would cause some applications which use the VK_KHR_display extension to segmentation fault

September 6th, 2019 — Linux 435.19.03

• Fixes:
  • Fixed a bug which caused corruption in the following DXVK titles:
    • Saints Row IV
    • Saints Row: The Third
  • Fall back to system memory when video memory is full for some driver-internal allocations.
    • This can help fix Xid 13 and Xid 31 cases when video memory is full.

August 29th, 2019 — Windows 436.20, Linux 435.19.02

• New:
  • Rebased Vulkan beta driver features to the latest 436.15 (Windows) and 435.17 (Linux) general release drivers
  • 8-bit integer support added to VK_NV_cooperative_matrix
    • See here for more info
• Fixes:
  • General performance imporvements from 436.15 and 435.17

August 12th, 2019 — Windows 426.06, Linux 418.52.20

• New:
  • VK_KHR_pipeline_executable_properties
• Fixes:
  • Improved reporting of Xid errors to include the process ID (PID) of the process responsible for the error

July 29th, 2019 — Windows 426.02, Linux 418.52.18

• New:
  • VK_EXT_index_type_uint8
  • VK_EXT_line_rasterization
  • VK_EXT_subgroup_size_control

July 17th, 2019 — Linux 418.52.17

• Fixes:
  • Fixed a bug that could cause heapUsage values reported by VK_EXT_memory_budget to not immediately update after vkFreeMemory was called

July 8th, 2019 — Windows 425.94, Linux 418.52.16

• New:
  • VK_KHR_imageless_framebuffer
• Fixes:
  • Improved compatibility with recent Linux kernel release candidates

July 1st, 2019 — Windows 425.89, Linux 418.52.14

• New:
  • VK_EXT_calibrated_timestamps (Linux)
  • VK_EXT_full_screen_exclusive
  • VK_EXT_shader_demote_to_helper_invocation
  • VK_EXT_texel_buffer_alignment
• Fixes:
  • Improved compatibility with recently released Linux kernels

June 1st, 2019 — Windows 425.62, Linux 418.52.10

• New:
  • VK_EXT_fragment_shader_interlock
  • VK_EXT_calibrated_timestamps (Windows)
  • VK_NV_shader_sm_builtins
• Fixes:
  • Fixes crash when changing presentMode between swapchains

May 22nd, 2019 — Windows 425.58, Linux 418.52.07

• New:
  • VK_KHR_uniform_buffer_standard_layout
  • VK_EXT_separate_stencil_usage

April 19th, 2019 — Windows 425.42, Linux 418.52.05

• New:
  • VK_PRESENT_MODE_IMMEDIATE_KHR present mode is now available for Windows
  • VK_NV_ray_tracing is now available on the following non-RTX GPUs:
    • Pascal: TITAN Xp, TITAN X, GeForce GTX 1080 Ti, GeForce GTX 1080, GeForce GTX 1070 Ti, GeForce GTX 1070, GeForce GTX 1060 6GB
    • Volta: TITAN V
    • Turing: GeForce GTX 1660 Ti, GeForce GTX 1660
  • VK_NV_coverage_reduction_mode
    • Extension specification will be available soon.
• Fixes:
  • Fix bug in vkCmdCopyImage with compressed images and some non-zero mipmap level dimensions
  • Fix bug with OpPhi and relaxed precision
  • Some minor performance improvements

April 10th, 2019 — Windows 425.30, Linux 418.52.03

• New:
  • VK_EXT_pipeline_creation_feedback
  • VK_KHR_surface_protected_capabilities
• Fixes:
  • Performance improvement for some content on Windows laptops
  • Fix rare startup instability on Windows

March 16th, 2019 — Windows 419.62, Linux 418.49.04

• New:
  • VK_EXT_host_query_reset
  • VK_EXT_ycbcr_image_arrays

March 1st, 2019 — Windows 419.34, Linux 418.42.02

• Fixes:
  • Fixes intermittent crash on startup with some content on Windows
  • Fixed a bug which could cause the compiler to crash in some Vulkan games

February 19th, 2019 — Windows 419.09, Linux 418.31.03

• New Extensions:
  • VK_NV_cooperative_matrix
  • VK_EXT_depth_clip_enable
• Fixes:
  • Hitman 2 visual corruption on Linux when running with dxvk translation
  • Total War Warhammer II crash or hang when using Alt-Tab on Linux

January 6th, 2019 — Windows 417.63, Linux 415.22.05

• New Extensions:
  • VK_KHR_depth_stencil_resolve
  • VK_EXT_buffer_device_address
  • VK_EXT_memory_budget
  • VK_EXT_memory_priority (Windows only)
  • VK_EXT_pci_bus_info
• Improvements:
  • Better pipeline creation performance when there is a cache hit

December 14th, 2018 — Windows 417.42, Linux 415.22.01

• Improvements:
  • Expose two transfer queues on Pascal and above
  • Increase maximum point size to 2047
  • Increate maximum line width to 64
• Fixes:
  • Fixed issue with vkCmdDrawIndirectCountKHR and vkCmdDrawIndexedIndirectCountKHR and very large counts.
  • Fixed issue with Sascha Willems «pushconstants» example.

December 2nd, 2018 — Windows 417.23, Linux 415.18.04

• New Extensions:
  • VK_KHR_shader_float16_int8
  • VK_KHR_shader_float_controls
• Fixes:
  • Fixes regression with Unity games on Linux

November 28th, 2018 — Windows 417.17, Linux 415.18.02

• Turing support
• New Extensions:
  • VK_KHR_swapchain_mutable_format
  • VK_EXT_scalar_block_layout
• Fixes:
  • VK_EXT_transform_feedback bug fixes

October 14th, 2018 — Windows 399.41, Linux 396.54.09

• New Extensions:
  • VK_EXT_external_memory_host (Windows only)
  • VK_EXT_transform_feedback

September 19th, 2018 — Windows 399.32, Linux 396.54.06

• New Extensions:
  • VK_KHR_driver_properties
  • VK_KHR_shader_atomic_int64
• Bug fixes:
  • Corruption workaround for DX content running on Vulkan

September 10th, 2018 — Windows 399.28, Linux 396.54.05

• New Extensions:
  • VK_KHR_vulkan_memory_model
  • VK_EXT_inline_uniform_block

August 31st, 2018 — Windows 399.17, Linux 396.54.02

• New Extensions:
  • VK_EXT_swapchain_colorspace (Windows only)
  • VK_EXT_hdr_metadata (Windows only)
• Bug fixes:
  • VK_EXT_vertex_attribute_divisor has been updated to version 3
  • Entry point queries for VK_EXT_conditional_rendering have been fixed
  • Missing primitives with some DXVK content has been fixed

August 7th, 2018 — Windows 398.91, Linux 396.51.02

• New Extensions:
  • VK_NV_device_diagnostic_checkpoints
• Bug fixes:
  • Fix hang that sometimes occurs after a clear in multisample rendering
  • Fix hang that sometimes occurs when doing a modeswitch while fullscreen
  • Other minor driver and SPIR-V compiler bug fixes

July 12th, 2018 — Windows 398.58, Linux 396.24.10

• New Extensions:
  • VK_KHR_8bit_storage
  • VK_KHR_create_renderpass2
  • VK_EXT_conditional_rendering
• Bug fixes:
  • Fixed an intermittent hang of Vulkan applications running fullscreen when flipping is allowed on Linux
  • Various other driver and compiler fixes

May 24th, 2018 — Windows 397.96, Linux 396.24.02

• Increased maxBoundDescriptorSets limit from 8 to 32
• New Extensions:
  • VK_KHR_draw_indirect_count
  • VK_EXT_global_priority (Linux only)
  • VK_KHR_get_display_properties2 (Linux only)
• Bug fixes:
  • Improved stability with Wine on Linux
  • Improve stability of Vulkan on pre-Pascal GPUs
  • Emulate DX shader behavior when necessary
  • Bounds-checking for SSBO variable pointer loads

May 11th, 2018 — Windows 397.76, Linux 396.18.11

• Pick up the latest fixes from general release driver 397.64

May 7th, 2018 — Linux 396.18.08

• Fix for the Alt-Tab freeze with DXVK

May 3rd, 2018 — Windows 397.54, Linux 396.18.07

• Shader compiler bug fixes

April 25th, 2018 — Windows 397.40, Linux 396.18.05

• Windows driver feature parity with Linux 396.18.02
• Bug fixes

April 17th, 2018 — Linux 396.18.02

• New Extensions
  • VK_EXT_descriptor_indexing
• Increased several resource limits, notably:
  • maxPerStageDescriptorUniformBuffers: 12 -> 15
  • maxPerStageDescriptorSamplers: 4,000 -> 1,048,576
  • maxPerStageDescriptorSampledImages: 16,384 -> 1,048,576
  • maxPerStageDescriptorStorageBuffers: 4,096 -> 1,048,576
  • And many others
• Shader performance improvements

March 30th, 2018 — Windows 389.20, Linux 387.42.06

• New Extensions
  • VK_EXT_vertex_attribute_divisor
  • VK_NV_shader_subgroup_partitioned

March 7th, 2018 — Windows 389.10, Linux 387.42.05

• Full support for Vulkan 1.1
• New Extensions
• VK_KHR_device_group_creation
• VK_KHR_device_group
• VK_KHR_maintenance3
• VK_KHR_multiview
• Updated loader to VulkanRT-1.1.70

January 5th, 2018 — Windows 388.84, Linux 387.42.01

• VK_EXT_conservative_rasterization

September 28th, 2017 — Windows 383.18, Linux 381.26.20

• Full-screen flipping for Linux
  • Improved performance of fullscreen Vulkan applications using X11 swapchains. This optimization will cause more events that trigger an out-of-date swapchain, such as when entering or leaving fullscreen mode. This is commonly encountered when using the alt-tab key combination, for example. Applications that do not properly respond to the VK_ERROR_OUT_OF_DATE_KHR return code may not function properly when these events occur. See section 30.8 of the Vulkan specification.
  • Known issue with Quadro and non-composited desktops under some situations. Possible workarounds:
    • Disable flipping in nvidia-settings (uncheck «Allow Flipping» in the «OpenGL Settings» panel)
    • Disable UBB (run ‘nvidia-xconfig —no-ubb’)
    • Use a composited desktop
• Bug fixes
  • NVX_multiview_per_view_attributes and geometry passthrough shaders
  • Fix subpass dstSubpass=VK_SUBPASS_EXTERNAL handling
  • Fix vkRegisterObjectsNVX and VK_EXT_sample_
  • Fix handling of SPIR-V SSBO layout qualifiers on members
  • Fix atomic operations on some 64-bit types

September 15th, 2017 — Windows 383.12, Linux 381.26.17

• New Extensions
  • VK_KHR_maintenance2
  • VK_KHR_bind_memory2
  • VK_KHR_image_format_list
  • VK_KHR_sampler_ycbcr_conversion
  • VK_EXT_sample_locations
• Removed KHX extensions
  • VK_KHX_external_memory_capabilities
  • VK_KHX_external_memory
  • VK_KHX_external_memory_fd
  • VK_KHX_external_memory_win32
  • VK_KHX_external_semaphore_capabilities
  • VK_KHX_external_semaphore
  • VK_KHX_external_semaphore_fd
  • VK_KHX_external_semaphore_win32
  • VK_KHX_win32_keyed_mutex
• Updated Vulkan loader to 1.0.61.0
• Minor bug fixes

August 16th, 2017 — Windows 382.96, Linux 381.26.13

• New Extensions
  • VK_EXT_shader_viewport_index_layer
• Updated Vulkan loader to 1.0.57.0
• Fixed potential hang with some semaphore usage patterns
• Fixed issue with VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX and dynamicCount
• Other minor bugs fixed

July 31st, 2017 — Windows 382.88, Linux 381.26.11

• New Extensions
  • VK_KHR_relaxed_block_layout
  • VK_EXT_depth_range_unrestricted
  • VK_EXT_post_depth_coverage
• Fixed crash with large sparse images

July 14th, 2017 — Windows 382.83

• Fixed issue with unused compute queue
• Other minor bug fixes

July 13th, 2017 — Linux 381.26.08, Windows 382.81

• New extensions:
  • VK_KHR_16bit_storage
  • VK_KHR_dedicated_allocation
  • VK_KHR_external_fence
  • VK_KHR_external_fence_capabilities
  • VK_KHR_external_fence_fd
  • VK_KHR_external_fence_win32
  • VK_KHR_external_memory
  • VK_KHR_external_memory_capabilities
  • VK_KHR_external_memory_fd
  • VK_KHR_external_memory_win32
  • VK_KHR_external_semaphore
  • VK_KHR_external_semaphore_capabilities
  • VK_KHR_external_semaphore_fd
  • VK_KHR_external_semaphore_win32
  • VK_KHR_get_memory_requirements2
  • VK_KHR_storage_buffer_storage_class
  • VK_KHR_variable_pointers
  • VK_KHR_win32_keyed_mutex
• Updated VulkanRT loader to 1.0.54.0
• Various performance improvements and bug fixes

June 30th, 2017 — Windows 382.71, Linux 381.26.06

• Various performance improvements and bug fixes

June 27th, 2017 — Windows 382.68, Linux 381.10.10

• New extensions:
  • Vulkan/OpenGL interop:
    • GL_EXT_memory_object
    • GL_EXT_memory_object_win32
    • GL_EXT_memory_object_fd
    • GL_EXT_semaphore
    • GL_EXT_semaphore_win32
    • GL_EXT_semaphore_fd
    • GL_EXT_win32_keyed_mutex
  • VK_EXT_blend_operation_advanced (Maxwell)
  • VK_NV_framebuffer_mixed_samples (Maxwell)
• Updated VulkanRT loader to 1.0.51.0
• Various performance improvements and bug fixes

June 9th, 2017 — Windows 382.58, Linux 381.26.03

• New extensions:
  • VK_KHR_get_surface_capabilities2
  • VK_EXT_sampler_filter_minmax (Maxwell)
  • VK_NV_fill_rectangle (Maxwell)
  • VK_NV_fragment_coverage_to_color (Maxwell)
• Updated VulkanRT loader to 1.0.49.0
• Various performance improvements

March 27th, 2017 — Windows 377.14, Linux 375.27.15

• SPIR-V compiler bug fixes
• Updated Vulkan loader to version 1.0.42.1

March 15th, 2017 — Windows 377.07

• Bug fixes

March 8th, 2017 — Linux 375.27.14, Windows 377.06

• Bug fixes

February 28th, 2017 — Linux 375.27.13, Windows 377.01

• Fix issue with SteamVR shaders

February 27th, 2017 — Linux 375.27.12, Windows 376.98

• Beta support for the following new extensions:

  Descriptor Set Extensions

  • VK_KHR_push_descriptor
  • VK_KHR_descriptor_update_template

  Cross process interop extensions:

  • VK_KHX_external_memory
  • VK_KHX_external_memory_capabilities
  • VK_KHX_external_memory_fd
  • VK_KHX_external_memory_win32
  • VK_KHX_external_semaphore
  • VK_KHX_external_semaphore_capabilities
  • VK_KHX_external_semaphore_fd
  • VK_KHX_external_semaphore_win32
  • VK_KHX_win32_keyed_mutex

  Multi-GPU extensions:

  • VK_KHX_device_group
  • VK_KHX_device_group_creation

  Multiview and VR related extensions:

  • VK_KHX_multiview
  • VK_NVX_multiview_per_view_attributes
  • VK_NV_viewport_swizzle (Maxwell)
  • VK_NV_viewport_array2 (Maxwell)
  • VK_NV_geometry_shader_passthrough (Maxwell)
  • VK_NV_clip_space_w_scaling (Pascal)

  Other extensions:

  • VK_NV_sample_mask_override_coverage (Maxwell)
  • VK_EXT_discard_rectangles
• Bug fixes to improve compatibility with shaders generated from HLSL

February 9th, 2017 — Linux 375.27.10

• Bug fixes

February 1st, 2017 — Linux 375.27.08, Windows 376.80

• Bug fixes

January 23rd, 2017 — Linux 375.27.07, Windows 376.71

• Beta support for the new Vulkan extensions:
  • VK_KHR_get_physical_device_properties2
  • VK_KHR_maintenance1
  • VK_KHR_shader_draw_parameters
  • VK_EXT_shader_ballot
  • VK_EXT_shader_group_vote

January 10th, 2017 — Linux 375.27.03, Windows 376.66

• Vulkan beta drivers with experimental API interop features

July 6th, 2016 — Windows 368.69

• Public GeForce Game Ready drivers

June 13th, 2016 — Linux 367.27

• Linux Display Driver

May 23rd, 2016 — Windows 368.22, Linux 367.18

• Public GeForce Game Ready drivers
• Bug fixes and performance improvements

May 13th, 2016 — Windows 365.19, Linux 364.19

• Public GeForce Game Ready drivers
• Bug fixes and performance improvements

April 8th, 2016 — Windows 364.91, Linux 364.16

• Updated Vulkan API to 1.0.8
• Improve pipeline creation performance and multi-threaded scaling
• Increase our maximum bound descriptor sets from 4 to 8
• Add support for asynchronous transfer queue
• Improve VK_EXT_debug_report messages on incorrect API usage and shader compile failure
• Fix VkImageFormatProperties maxMipLevels property
• Reduce VkPhysicalDeviceLimits bufferImageGranularity requirement on GM20x GPUs
• Improve Vulkan support on Optimus platforms
• Fixes for minor driver and SPIR-V compiler bugs

March 28th, 2016 — Windows 364.72

• Update Vulkan API to 1.0.5
• Various performance improvements
• Various bug fixes

March 21st, 2016 — Linux 364.12

• Linux UDA drivers

March 10th, Windows 364.51

• Windows WHQL drivers

March 2nd, 2016 — Windows 356.45, Linux 355.00.29

• Support Vulkan API version v1.0.4
• Fix device lost issue with some MSAA resolves
• Fix vkGetQueryPoolResults() when queryCount=0
• Fix OpImageQuerySample with images
• Fix OpVectorExtractDynamic issues with doubles
• Fix handling of sparse image miptail when the whole image fits within a page
• Improve vkAcquireNextImageKHR() conformance to WSI spec
• Improve GL_KHR_vulkan_glsl compatibility when using GLSL directly
• Improve GPU texturing performance in some cases
• Improve vkAllocateDescriptorSets()/vkFreeDescriptorSets() performance in some cases
• Improve vkCmdBindDescriptorSets() performance in some cases
• Improve vkCmdCopyImage() performance in some cases

February 23rd, 2016 — Windows 356.43, Linux 355.00.28

• Add support for 64-bit vertex attribute formats
• Improve performance of vkBindBufferMemory, vkBindImageMemory and vkCreateGraphicsPipelines
• No longer enumerate Fermi based GPUs in vkEnumeratePhysicalDevices
• Improved compatibility with recent Linux kernels

February 18th, 2016 — Linux 355.00.27

• New:
  • GL_NV_draw_vulkan_image
  • VK_NV_glsl_shader
• Fixes:
  • Linux: Fixed issue with vkAllocateMemory() crashing under some circumstances

Vulkan on NVIDIA Hardware FAQ

1) How do I start using Vulkan in my code base?

NVIDIA Vulkan developer page https://developer.nvidia.com/Vulkan is a great place to start. You can learn from Vulkan presentations and articles as well as NVIDIA demos and SDK samples.

2) Is NVIDIA going to continue to support OpenGL in the future?

NVIDIA is fully committed to invest in OpenGL that our ISVs rely on and will continue to support and improve it. NVIDIA believes in providing maximum functionality with minimal churn to developers. Hence, NVIDIA fully supports both Vulkan and OpenGL.

3) Is NVIDIA Vulkan driver conformant?

Yes, the beta drivers typically pass the latest version of Vulkan conformance. Current conformance status can be found at https://www.khronos.org/conformance/.

4) Does NVIDIA support Vulkan on Linux for Tegra?

Yes. Linux for Tegra drivers can be found at https://developer.nvidia.com/embedded/linux-tegra.

5) Does NVIDIA support Vulkan on Android?

Yes. See https://developer.nvidia.com/vulkan-android for details about NVIDIA Vulkan Android drivers for SHIELD devices.

Время от времени вы прокручиваете список программ, просматриваете установленные приложения, рабочие процессы в диспетчере задач, и наверняка натыкались на не известную вам программу, процесс. Одной из таких программ с которой вы столкнетесь это Vulkan Run Time Libraries. Давайте выясним, что это такое, цель программы и что вы должны с этим делать. Заранее скажу, что это не вирус и не программа от казино «Вулкан».

Для чего нужен Vulkan?

Vulkan находится на моем компьютере?

Вы можете легко проверить, есть ли у вас библиотеки Vulkan Run Time Libraries, установленные на вашем компьютере или ноутбуке.

В Windows 10 откройте «Все параметры» > «Приложения» > «Приложении и Возможности«. Если вы видите запись Vulkan Run Time Libraries 1.0.54.0 или другую версию, значит он установлен уже в вашей системе Windows 10.

В Windows 7 зайдите в «Панель управления» > «Программы и компоненты» или «Удаление программ». Прокрутите страницу вниз, чтобы найти запись.

Еще можно просто зайти на локальный системный диск, где установлена сама windows, по следующему пути C:Program Files (x86)VulkanRT. Она может быть в папке и без (x86).

Как Vulkan попал на мой компьютер?

Если вы не помните установку Vulkan, то не переживайте. Когда вы обновили или установили новейшие драйвера видеокарты, то Vulkan Run Time Libraries установится автоматически. Обе графические карты NVIDIA и AMD теперь включают в себя Vulkan с обновлением драйверов. Поскольку Vulkan был выпущен только в начале 2016 года, старые видеокарты могут его не поддерживать.

Какие игры поддерживает Vulkan?

Помимо этих игр, эмуляторы поддерживают Vulkan, такие как Dolphin (который эмулирует Nintendo GameCube) и игровые движки, такие как Source 2, Unity и CryEngine. Таким образом, мы можем ожидать больше игр с помощью Vulkan в будущем.

Должен ли я удалить Vulcan?

Если у вас установлен Vulkan на вашем компьютере, то вы скорее всего геймер или любитель поиграть в игры. Поскольку он загружается только с новейшими драйверами видеокарты. Вы не получите Vulkan при использовании встроенной видеокарты с интегрированной графикой.

Вы обязательно должны оставить и не удалять Vulkan с компьютера. Поскольку это новейший графический API, без помощи которого вы не сможете запускать более новые игры. Кроме того, нет возможности установить отдельно программу Vulkan Run Time Libraries. Если вы удалите ее, и решили потом снова установить, то вам придется переустановить графические драйверы видеокарт. Наличие этой библиотеки на вашем компьютере не приведет ни к каким поломкам. Он занимает мало места, не отвлекает вас разными уведомлениями и не является вирусом, как многие думают.

Теперь вы знаете, что такое Vulkan Run Time Libraries, почему они находятся на вашем компьютере и что они делают для вас. Любой компьютерный геймер должен иметь этот набор библиотек в своей системе, чтобы последние игры шли гладко. Вы должны получать обновления для Vulkan, когда вы обновляете свои графические драйверы, поэтому вам не о чем беспокоиться.

Источник

Что такое драйвера VulkanRT(Run Time Libraries) для Windows?

Vulkan Run Time Libraries — кроссплатформенный API для работы с 2D и 3D графикой и повышения производительности графического процессора. Разработана компаниями AMD и Khronos Group, но используется также NVidia и другими разработчиками.

VulkanRT — это нужные драйвера для Windows, которые не следует удалять. Это не вирус и не тот вулкан, который предложит крутить барабан. Vulcan API повышает производительность графического процессора видеокарты, заставляя её работать с максимальной эффективностью. Помимо новых версий Windows, технология также применяется на Linux и Android.

Папка с Vulkan Run Time Libraries находится в Program Files и весит совсем немного, программа также отображается в списке установленных программ и среди иных драйверов и компонентов Windows. Многие пользователи не знают, что за программа VulkanRT, и по ошибке путают эти драйвера с рекламными вирусами.

Что такое VulkanRT и зачем он Windows

В России распространено игровое вирусное ПО со словом «Вулкан», поэтому название VulkanRT вызывает опаску у пользователей. Это полезные драйвера для работы с графикой, динамические библиотеки Vulkan Run Time Libraries от разработчика NVidia.

Обычно приложение попадает на компьютер без ведома пользователей — вместе с новыми драйверами или при обновлении ПО. Драйвера можно поставить самостоятельно, если загрузить и установить приложение GeForce Experience с сайта NVidia.

В текущей версии вся программа состоит из нескольких файлов:

Если же установленная на компьютере программа каким-либо образом не попадает под это описание, следует очень внимательно перепроверить, действительно ли это драйвера. Особенно в том случае, если эта статья оказалась нужна не из-за предосторожности, а по причине появления рекламных вирусов в системе.

Стоит ли удалять VulkanRT с компьютера?

В первую очередь VilkanRT и Vilcan api нужны геймерам, играющим в современные игры с последними версиями библиотек DirectX. Приложение vulkaninfo.exe и остальные элементы драйверов нужны последним версиям DirectX 12 для повышения качества изображения в компьютерных играх.

Если драйвера удалить, такие игры не могут работать на максимальных настройках графики, часть настроек будут недоступны. Отдельные игры могут вообще не запуститься — это уже стало головной болью многих геймеров, которые после этого ищут инструкции, как скачать и установить VulcanRT и API. Для Windows 8/10 и Linux ПО Vulcan можно загрузить на сайте NVivia.com.

Тем не менее, некоторым пользователям не нравится технология Vulkan — он делает изображение более «расплывчатым», сглаживая картинку ради реалистичности. Драйвера также можно удалить, если на компьютере нет игр и других приложений, использующих VulkanRT.

Удалить vulkaninfo.exe можно через стандартный деинсталлятор Windows:

После перезагрузки компьютера все файлы и записи в системе будут удалены. При необходимости всегда можно загрузить драйвера заново с сайта NVidia. Помимо этого, Vulcan может установиться заново вместе с новыми играми, при обновлении DirectX или иного ПО для видеокарты.

Источник

Vulkan Driver Support

This page provides links to both Vulkan 1.2 general release drivers, and developer beta drivers.

Vulkan 1.2 General Release Driver Downloads

Vulkan 1.2, including support for the Vulkan Ray Tracing extensions, is available for Windows and Linux in our general release drivers here:

Vulkan Beta Driver Downloads

Vulkan Beta Driver Release Notes

The latest Vulkan 1.2 specification can be found here: https://www.khronos.org/registry/vulkan/

NVIDIA provides full Vulkan 1.2 support and functionality on NVIDIA GeForce and Quadro graphics card with one of the following Ampere, Turing, Volta, Pascal and Maxwell (first and second generation) based GPUs:

Ampere GPU Architecture

Turing GPU Architecture

Volta GPU Architecture

Pascal GPU Architecture

Maxwell 2 GPU Architecture

Maxwell 1 GPU Architecture

For any bugs or issues, please file a bug through the developer website: https://devtalk.nvidia.com/

Vulkan Beta Driver Release Updates

Descriptor Set Extensions

Cross process interop extensions:

Multi-GPU extensions:

Multiview and VR related extensions:

Other extensions:

March 10th, Windows 364.51

Vulkan on NVIDIA Hardware FAQ

1) How do I start using Vulkan in my code base?

NVIDIA Vulkan developer page https://developer.nvidia.com/Vulkan is a great place to start. You can learn from Vulkan presentations and articles as well as NVIDIA demos and SDK samples.

2) Is NVIDIA going to continue to support OpenGL in the future?

NVIDIA is fully committed to invest in OpenGL that our ISVs rely on and will continue to support and improve it. NVIDIA believes in providing maximum functionality with minimal churn to developers. Hence, NVIDIA fully supports both Vulkan and OpenGL.

3) Is NVIDIA Vulkan driver conformant?

Yes, the beta drivers typically pass the latest version of Vulkan conformance. Current conformance status can be found at https://www.khronos.org/conformance/.

4) Does NVIDIA support Vulkan on Linux for Tegra?

5) Does NVIDIA support Vulkan on Android?

Источник

Библиотеки Вулкана RunTime: Что это и почему на моем компьютере?

«Что такое Vulkan Runtime Libraries и почему он установлен на моем компьютере?»

Этот вопрос многие задают, когда сталкиваются с Vulkan RT в своих программах.

На первый взгляд, это почти похоже на вирус.

Но не волнуйся. Это не опасно.

Vulkan — это API для трехмерной графики и вычислений, который может расширить возможности вашего ПК.

Объясним в этой заметке все о библиотеках времени выполнения вулкана.

Какова функция библиотек времени исполнения Вулкана?

Будет немного занудно, так что оставайся с нами.

Vulkan Runtime Libraries (или VulkanRT), это то, что мы называем «Интерфейсом прикладного программирования», или API, производимый компания под названием «Хронос Груп.

API — это скрипт, позволяющий быстро обмениваться данными двум программным продуктам. Он делает это путем ведения журналов или «библиотек» кода, которые ваш компьютер может понять без необходимости искать информацию.

Всякий раз, когда эти две части программного обеспечения пытаются общаться, ваш компьютер прибегает к библиотекам, чтобы вспомнить, как облегчить их взаимодействие.

Можно подумать, что это заметки, которые компьютер пишет на своей руке или на дне обуви, чтобы обмануть тест. Так как информация находится на жестком диске, вашему компьютеру не нужно ее запоминать.

В этом случае, Vulkan API облегчает разговор между вашей видеокартой и любой видеоигрой или программным обеспечением (но, честно говоря, это в основном для игр), которые вы запускаете.

Ведь многие сегодняшние видеоигры супер высокого качества и посылают тонны информации драйверу видеокарты.

Библиотеки времени исполнения Vulkan Runtime Libraries хранят всю эту информацию, чтобы видеокарта знала, как обрабатывать эту информацию при каждом контакте.

Теперь такие компании, как Intel, Nvidia и AMD знают, что их продукция пользуется популярностью у геймеров.

Они хотят оптимизировать свои видеокарты, чтобы завлечь геймеров купить их. Если они смогут предоставить лучшую графику для видеоигр, большее количество игроков, скорее всего, предпочтут их другой компании.

Таким образом, все эти производители включили Vulkan в качестве функции своего последнего обновления. Это дает геймерам мгновенный доступ к программному обеспечению, которое улучшает их игровой опыт.

Но многие владельцы неигровых ПК после обновления случайно оказались с библиотеками Vulkan Runtime Libraries в своей панели управления.

Игры, которые поддерживают Вулкан

К сожалению, не каждая видеоигра поддерживает Вулкан. Microsoft имеет свой собственный API 3D графики, DirectX, поэтому большинство их игр (например, Minecraft, Halo и т.д.) не совместимы.

Как видите, существует множество игр, которые поддерживают Vulkan Runtime Libraries. Некоторые из классических (и новых игр) включают в себя:

Она также поддерживается несколькими эмуляторами игровых консолей и игровыми движками.

Vulkan vs. DirectX и OpenGL

Геймеры-ветераны знают, что Vulkan Runtime Libraries — это, несомненно, не первый API для улучшения графики. Эта концепция существует уже довольно давно.

Это преемник OpenGL, первой попытки Вулкана оптимизировать графику.

И как мы указывали выше, Вулкан находится в тесной конкуренции с Microsoft, которая делает 3D API под названием DirectX.

Тем не менее, есть несколько очевидных преимуществ Runtime Libraries перед конкурентами. К ним относятся:

Но, несмотря на то, что это отличная программа, у нее также есть несколько недостатков:

Тем не менее, вы не найдете улучшение графики лучше, чем Vulkan Runtime Libraries. Некоторые утверждают, что DirectX на паритетных началах, но это не очевидный победитель в дебатах.

Где можно скачать Вулкана?

Вы хотите оптимизировать свой игровой опыт с Вулканом?

Если у вас есть видеокарта Intel, Nvidia или AMD, скорее всего, она уже есть на вашем компьютере. API был добавлен в качестве функции в каждое из последних обновлений компании.

Проверить, установлена ли она уже, можно, набрав «Vulkan» в строке поиска в меню «Пуск».

Или вы можете проверить панель управления вашего компьютера. Если она уже установлена на вашем компьютере, вы должны увидеть ее там.

Если его там нет, вам придется его установить.

К сожалению, единственный способ установить Vulkan Runtime Libraries на компьютер — это обновить драйверы.

А для обновления драйверов вам понадобится драйвер, поддерживающий Vulkan. Иначе обновление ничего не сделает.

Вот полный список компаний, драйверы которых поддерживают Вулкан:

В зависимости от типа вашего драйвера, вам нужно будет перейти на сайт производителя и следовать инструкциям по обновлению драйвера.

Обновление драйвера Nvidia для установки библиотек времени исполнения Vulkan

У каждого производителя драйверов свой процесс модернизации.

Мы используем пример водителя Nvidia, чтобы показать вам, как мы это сделали. Если в вашем компьютере установлена видеокарта Nvidia, вы должны следовать следующим инструкциям.

У некоторых других производителей аналогичный процесс. Для обновления графического драйвера AMDты будешь следовать тем же шагам.

Однако с такими компаниями, как Intel, вы можете необходимо скачать помощник поддержки Сначала.

Должен ли я удалить библиотеки времени исполнения Вулкана с моего компьютера?

Как мы указывали выше, нет никаких реальных причин для деинсталляции Библиотек.

Но, если вы не планируете играть в игры, которые требуют этого, мы понимаем, что вы, возможно, захотите избавиться от этого.

Пожалуйста, обратите внимание: как только вы удалите его из компьютера, вам будет трудно переустановить его. Возможно, вам понадобится купить новую видеокарту, если вы решите, что хотите получить ее снова.

Все еще хочешь двигаться вперед? Вот как деинсталлировать библиотеки Вулкана:

Доступен ли Vulkan API для Mac OS?

Компьютеры — это оборудование, которое выбирают большинство геймеров. Однако есть и несколько пользователей Mac.

И у многих из них один и тот же вопрос: Могу ли я скачать Vulkan Runtime Libraries для своего компьютера Mac?

Долгое время Вулкан вообще не был совместим с операционной системой Macintosh. Но в феврале 2018 года компания API объявила, что их приложения будут включённый на платформах Apple.

Это имеет смысл, учитывая тот факт, что большинство компьютеров Mac оснащены видеокартами Intel или Nvidia.

Но Mac не хочет, чтобы люди скачивали Vulkan, потому что у них есть свой API под названием Metal. Они предпочитают, чтобы их клиенты использовали его.

Так что вы не можете скачать Runtime Libraries напрямую. Вместо этого вы можете скачать MolkenVK, API Vulkan с открытым исходным кодом и дружественным к Mac, который работает в рамках Metal. Он обладает теми же функциями, что и другие продукты Vulkan, и предлагает многие из тех же преимуществ.

Есть два способа загрузить его:

Оба сайта довольно понятны. Все, что вам нужно сделать, это нажать кнопку «Загрузить», следовать инструкциям и позволить API сделать свое дело.

Почему мой программный флаг Вулкан был угрозой?

В некоторых случаях антивирусное программное обеспечение может обнаружить Vulkan RT и уведомить вас об угрозе.

Давайте повторим: Это не проблема. Библиотеки не причинят вреда вашему компьютеру.

Причина, по которой это происходит, заключается в том, что Vulkan обычно устанавливается в фоновом режиме. Он поставляется как функция на вашей видеокарте Nvidia или Intel. В результате, устаревшее антивирусное программное обеспечение может не распознать его.

Или, возможно, вы работаете с антивирусным программным обеспечением freemium, на которое еще не подписаны. В этих случаях Вы можете получить предупреждение, потому что антивирусное программное обеспечение работает не на премиум уровне.

И то, и другое легко исправить. Вам нужно либо удалить антивирусное программное обеспечение и получить новое, начать платить за премиум-аккаунт, либо найти другую бесплатную пробную версию и использовать ее до тех пор, пока она не перестанет работать.

Что если у меня на компьютере несколько версий?

Вот общая проблема: пользователь ПК открывает свою панель управления, чтобы увидеть не одну, а две и более версии библиотек Vulkan Runtime Libraries на своем компьютере:

Конечно, это не идеально. Программное обеспечение занимает много места, а две или три версии могут привести к раздуванию компьютера.

К сожалению, Вулкан не сделал большой работы, чтобы каждая версия их программного обеспечения перезаписывалась последней.

Таким образом, вам, возможно, придется пойти и удалить каждую новую версию вручную.

Это не сложно. Вы можете следовать инструкциям по деинсталляции, которые мы описали выше. Но вам нужно убедиться, что вы удалите правильную версию.

Мы рекомендуем использовать страницу «Загрузка драйверов Nvidia», чтобы определить последнюю версию. Это та версия, которая должна быть у вас; вы можете удалить все дополнительные, устаревшие версии.

Если только у тебя нет нескольких версий… Вулкан РТ — лучший оставшийся один.

Мы знаем, что открывать панель управления и находить различные программы, которые вы никогда сознательно не скачиваете, — это неприятно.

Но, честно говоря, Вулкану не о чем беспокоиться. Даже если на вашем компьютере есть несколько версий, их довольно легко удалить.

В самом худшем случае, в следующий раз, когда вы будете играть в Quake, вы испытаете убийственную графику. И если игра не ваша стихия, вы, вероятно, даже не заметите ее.

И это завершает нашу статью о библиотеках времени выполнения вулкана. Надеюсь, вы узнали что-то новое!

Источник

Что такое VulkanRT?

Что такое VulkanRT? Вирус или полезная программа?

Одним из самых распространенных вирусов в России является Вулкан. Данное вредоносное программное обеспечение проникает на компьютеры пользователей против их желания и приносит массу проблем. Вследствие этого неудивительно, что у некоторых пользователей установленное на компьютере приложение VulkanRT вызывает опаску. Складывается впечатление, что оно является частью вируса Вулкан, но это не так.

Сегодня мы все чаще сталкиваемся с программой VulkanRT. Но не спешите связывать ее с вирусом. В отличие от одноименного вируса, это приложение несет большую пользу.

Разработкой приложения VulkanRT занимается компания NVidia, которая известна всему миру своими видеокартами для компьютеров. Данная программа необходима, чтобы повысить мощность и производительность компонентов от NVidia в играх и тяжелых приложениях.

Что за программа VulkanRT?

Современные видеокарты поддерживают технологию обработки трехмерных изображений OpenGL. Расширение для работы с OpenGL есть в стандартном наборе драйверов для дискретных видеокарт. Индустрия трехмерных игр не стоит на месте, и существующая технология обработки оказалась устаревшей. Новое поколение видеокарт от GeForce Nvidia для обработки широкополигональных игровых текстур использует новый тип драйверов.

VulkanRT – это (Драйвер) продолжение традиций OpenGL в новом исполнении. Появилась эта технология с релизом Windows 10. Поэтому сегодня все больше пользователей сталкиваются с одноименным процессом в диспетчере задач и системными папками с аналогичным названием.

VulkanRT Nvidia — кроссплатформенное приложение. Софт оказался удачным, и подходит для компьютера, для мобильных устройств и консолей. Разработчики считают технологию удачной за счет оптимизации ресурсов, и потенциала, поэтому в ближайшем будущем она будет применяться в новых устройствах и окончательно заменит устаревшую технологию OpenGL.

Как программа VulkanRT попадает на компьютер?

Главный повод для тревоги – самовольная установка программы в систему. На самом деле – VulkanRT это часть пакета драйверов, поэтому ПО от Nvidia и не запрашивает разрешения пользователя на установку.

По адресу в проводнике C:Program Files (x86)VulkanRT1.0.3.0;

Как удалить VulkanRT?

Как мы отметили выше, приложение VulkanRT не является вирусом, и его удаление приведет к снижению мощности компьютера из-за отсутствия актуальных драйверов для работы видеокарты.

Если вы все же решили удалить VulkanRT, то сделать это можно через файл UnistallVulkanRT в папке с программой, через стандартную «Установку и удаление программ» или с помощью сторонних приложений.

Где и как скачать VulkanRT?

VulkanRT самостоятельно скачивается и устанавливается при обновлении драйверов.

Если у вас выключено автообновление, то зайдите в панель управления, пункт «Система и безопасность», далее «Центр обновления Windows» после чего выбираем «Настройка параметров». Выбираем в меню «Важные обновления» параметр «Устанавливать обновления автоматически».

Теперь вы не пропустите обновление NVIDIA, а вместе с ним и VulkanRT 1.0.3.0.

Скачать VulkanRT (Vulkan Driver) для ОС Windows и Linux.
(Официальный сайт NVIDIA)

Предлагаем посмотреть ролик для оценки возможностей нового поколения OpenGL — Vulkan API:

Так все же вредоносная это программа VulkanRT или нет? Однозначно нет! Просто из-за одинаковых названий её путают с вирусом Vulkan, а точнее «Вулкан казино».

Источник

Оглавление:

• Что такое Vulkan и каковы его преимущества?
• Как установить Vulkan на свой компьютер

Vulkan — это API моды вместе с DirectX 12, в этой статье мы расскажем обо всех его преимуществах и объясним, как очень просто установить Vulkan, чтобы вы могли использовать весь его потенциал на вашем ПК.

Что такое Vulkan и каковы его преимущества?

Vulkan — это кроссплатформенный API-интерфейс для трехмерной графики и вычислений. Vulkan предназначен для высокопроизводительных приложений 3D-графики в реальном времени, таких как видеоигры и интерактивные медиа, на всех платформах. По сравнению с OpenGL и Direct3D 11, а также Direct3D 12 и Metal, Vulkan предлагает более высокую производительность и более сбалансированное использование CPU / GPU. Другие важные различия между Direct3D 11 и более ранними версиями и OpenGL заключаются в том, что Vulkan является значительно более низким уровнем API и предлагает параллельные задачи. Vulkan также имеет возможность рендеринга приложений 2D-графики, однако, как правило, он больше подходит для 3D. В дополнение к более низкой загрузке процессора, Vulkan также может лучше распределять работу между несколькими ядрами процессора. В общем, Vulkan, как говорят, вызывает ускорение в любом месте от предельного до полиномиального во время выполнения по сравнению с другими API, если правильно реализовано на том же оборудовании.

Впервые Vulkan был анонсирован некоммерческой организацией Khronos Group на GDC 2015. Изначально Khronos называл Vulkan API «Инициативой OpenGL следующего поколения», или «OpenGL next», но использование этих имен было прекращено после того, как было объявлено имя Vulkan. Vulkan создан на основе компонентов AMD Mantle API, который AMD подарил компании Khronos с целью дать Khronos основу для разработки низкоуровневого API, который они могли бы стандартизировать в отрасли., как OpenGL.

Vulkan призван обеспечить множество преимуществ по сравнению с другими API, а также его предшественник OpenGL. Vulkan предлагает меньшую нагрузку, более прямой контроль над графическим процессором и меньшую загрузку процессора. Общая концепция и набор функций Vulkan аналогичны Direct3D 12, Metal и Mantle.

Ожидаемые преимущества Vulkan по сравнению с API предыдущего поколения включают в себя:

• Vulkan API хорошо подходит для высококачественных видеокарт, а также для графического оборудования на мобильных устройствах.В отличие от Direct3D 12, Vulkan доступен в нескольких современных операционных системах; Как и OpenGL, Vulkan API не привязан к одной операционной системе или форм-фактору устройства. Начиная с запуска, Vulkan работает на Android, Linux, Tizen, Windows 7, Windows 8 и Windows 10. Снижение нагрузки на драйверы, снижение нагрузки на процессор. Снижение нагрузки на процессор за счет использования пакетной обработки, что позволяет процессору выполнять больше вычислений или визуализаций, чем в противном случае. Лучшее масштабирование на многоядерных процессорах. Direct3D 11 и OpenGL 4 изначально были разработаны для использования с одноядерными процессорами, и получили поддержку только для нескольких ядер. Даже когда разработчики приложений используют дополнения, API регулярно плохо адаптируется к нескольким ядрам. OpenGL использует высокоуровневый язык GLSL для написания шейдеров, заставляя каждый драйвер OpenGL реализовывать свой собственный компилятор для GLSL, который выполняется во время выполнения приложения для преобразования программных шейдеров в машинный код графического процессора., Вместо этого драйверы Vulkan должны принимать уже переведенные шейдеры в промежуточный двоичный формат, называемый SPIR-V (стандартное портативное промежуточное представление), аналогично двоичному формату, в котором шейдеры HLSL компилируются в Direct3D. Благодаря возможности предварительной компиляции шейдера скорость инициализации приложения улучшается, и для каждой сцены можно использовать более широкий набор шейдеров. Драйвер Vulkan должен выполнять только специфичную для графического процессора оптимизацию и генерацию кода, что приводит к упрощению обслуживания драйверов и, в конечном итоге, к уменьшению пакетов драйверов. Унифицированное управление вычислительными ядрами и графическими шейдерами, исключающее необходимость использования отдельного API вычислений в сочетании с API-интерфейсом графов.

Как установить Vulkan на свой компьютер

Установить Vulkan на свой ПК так же просто, как установить драйверы видеокарты, поскольку и Nvidia, и AMD включают в них Vulkan. Первый шаг — найти драйвер для вашей видеокарты и операционной системы на веб-сайте Nvidia или AMD.

Как только драйвер выбран, мы загружаем его на наш ПК и можем установить его, для этого нам просто нужно запустить файл и выполнить шаги мастера.

Программа установки даст нам возможность также установить программное обеспечение GeForce Experience.

Мы рекомендуем сделать экспресс-установку, таким образом мы избежим возможных проблем. После этого нам остается только дождаться окончания установки.

Мы рекомендуем прочитать наше руководство по лучшим видеокартам и как чистить видеокарту шаг за шагом

На этом заканчивается наша статья о том, как установить Vulkan на ваш компьютер, помните, что вы можете оставить комментарий, если у вас есть какие-либо вопросы или вы хотите сделать предложение.

• Windows

  • Vulkan SDK

  • GLFW

  • GLM

  • Setting up Visual Studio

• Linux

  • Vulkan Packages

  • GLFW

  • GLM

  • Shader Compiler

  • Setting up a makefile project

• MacOS

  • Vulkan SDK

  • GLFW

  • GLM

  • Setting up Xcode

In this chapter we’ll set up your environment for developing Vulkan applications
and install some useful libraries. All of the tools we’ll use, with the
exception of the compiler, are compatible with Windows, Linux and MacOS, but the
steps for installing them differ a bit, which is why they’re described
separately here.

Windows

If you’re developing for Windows, then I will assume that you are using Visual
Studio to compile your code. For complete C++17 support, you need to use either
Visual Studio 2017 or 2019. The steps outlined below were written for VS 2017.

Vulkan SDK

The most important component you’ll need for developing Vulkan applications is
the SDK. It includes the headers, standard validation layers, debugging tools
and a loader for the Vulkan functions. The loader looks up the functions in the
driver at runtime, similarly to GLEW for OpenGL — if you’re familiar with that.

The SDK can be downloaded from the LunarG website
using the buttons at the bottom of the page. You don’t have to create an
account, but it will give you access to some additional documentation that may
be useful to you.

Proceed through the installation and pay attention to the install location of
the SDK. The first thing we’ll do is verify that your graphics card and driver
properly support Vulkan. Go to the directory where you installed the SDK, open
the Bin directory and run the vkcube.exe demo. You should see the following:

If you receive an error message then ensure that your drivers are up-to-date,
include the Vulkan runtime and that your graphics card is supported. See the
introduction chapter for links to drivers from the major
vendors.

There is another program in this directory that will be useful for development. The glslangValidator.exe and glslc.exe programs will be used to compile shaders from the
human-readable GLSL to
bytecode. We’ll cover this in depth in the shader modules
chapter. The Bin directory also contains the binaries of the Vulkan loader
and the validation layers, while the Lib directory contains the libraries.

Lastly, there’s the Include directory that contains the Vulkan headers. Feel free to explore the other files, but we won’t need them for this tutorial.

GLFW

As mentioned before, Vulkan by itself is a platform agnostic API and does not
include tools for creating a window to display the rendered results. To benefit
from the cross-platform advantages of Vulkan and to avoid the horrors of Win32,
we’ll use the GLFW library to create a window, which
supports Windows, Linux and MacOS. There are other libraries available for this
purpose, like SDL, but the advantage of GLFW is that
it also abstracts away some of the other platform-specific things in Vulkan
besides just window creation.

You can find the latest release of GLFW on the official website.
In this tutorial we’ll be using the 64-bit binaries, but you can of course also
choose to build in 32 bit mode. In that case make sure to link with the Vulkan
SDK binaries in the Lib32 directory instead of Lib. After downloading it, extract the archive
to a convenient location. I’ve chosen to create a Libraries directory in the
Visual Studio directory under documents.

GLM

Unlike DirectX 12, Vulkan does not include a library for linear algebra
operations, so we’ll have to download one. GLM is a
nice library that is designed for use with graphics APIs and is also commonly
used with OpenGL.

GLM is a header-only library, so just download the latest version
and store it in a convenient location. You should have a directory structure
similar to the following now:

Setting up Visual Studio

Now that you’ve installed all of the dependencies we can set up a basic Visual
Studio project for Vulkan and write a little bit of code to make sure that
everything works.

Start Visual Studio and create a new Windows Desktop Wizard project by entering a name and pressing OK.

Make sure that Console Application (.exe) is selected as application type so that we have a place to print debug messages to, and check Empty Project to prevent Visual Studio from adding boilerplate code.

Press OK to create the project and add a C++ source file. You should
already know how to do that, but the steps are included here for completeness.

Now add the following code to the file. Don’t worry about trying to
understand it right now; we’re just making sure that you can compile and run
Vulkan applications. We’ll start from scratch in the next chapter.

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supportedn";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Let’s now configure the project to get rid of the errors. Open the project
properties dialog and ensure that All Configurations is selected, because most
of the settings apply to both Debug and Release mode.

Go to C++ -> General -> Additional Include Directories and press <Edit...>
in the dropdown box.

Add the header directories for Vulkan, GLFW and GLM:

Next, open the editor for library directories under Linker -> General:

And add the locations of the object files for Vulkan and GLFW:

Go to Linker -> Input and press <Edit...> in the Additional Dependencies
dropdown box.

Enter the names of the Vulkan and GLFW object files:

And finally change the compiler to support C++17 features:

You can now close the project properties dialog. If you did everything right
then you should no longer see any more errors being highlighted in the code.

Finally, ensure that you are actually compiling in 64 bit mode:

Press F5 to compile and run the project and you should see a command prompt
and a window pop up like this:

The number of extensions should be non-zero. Congratulations, you’re all set for
playing with Vulkan!

Linux

These instructions will be aimed at Ubuntu, Fedora and Arch Linux users, but you may be able to follow
along by changing the package manager-specific commands to the ones that are appropriate for you. You should have a compiler that supports C++17 (GCC 7+ or Clang 5+). You’ll also need make.

Vulkan Packages

The most important components you’ll need for developing Vulkan applications on Linux are the Vulkan loader, validation layers, and a couple of command-line utilities to test whether your machine is Vulkan-capable:

• sudo apt install vulkan-tools or sudo dnf install vulkan-tools: Command-line utilities, most importantly vulkaninfo and vkcube. Run these to confirm your machine supports Vulkan.
• sudo apt install libvulkan-dev or sudo dnf install vulkan-loader-devel : Installs Vulkan loader. The loader looks up the functions in the driver at runtime, similarly to GLEW for OpenGL — if you’re familiar with that.
• sudo apt install vulkan-validationlayers-dev spirv-tools or sudo dnf install mesa-vulkan-devel vulkan-validation-layers-devel: Installs the standard validation layers and required SPIR-V tools. These are crucial when debugging Vulkan applications, and we’ll discuss them in the upcoming chapter.

On Arch Linux, you can run sudo pacman -S vulkan-devel to install all the
required tools above.

If installation was successful, you should be all set with the Vulkan portion. Remember to run
vkcube and ensure you see the following pop up in a window:

If you receive an error message then ensure that your drivers are up-to-date,
include the Vulkan runtime and that your graphics card is supported. See the
introduction chapter for links to drivers from the major
vendors.

GLFW

As mentioned before, Vulkan by itself is a platform agnostic API and does not
include tools for creation a window to display the rendered results. To benefit
from the cross-platform advantages of Vulkan and to avoid the horrors of X11,
we’ll use the GLFW library to create a window, which
supports Windows, Linux and MacOS. There are other libraries available for this
purpose, like SDL, but the advantage of GLFW is that
it also abstracts away some of the other platform-specific things in Vulkan
besides just window creation.

We’ll be installing GLFW from the following command:

sudo apt install libglfw3-dev

or

sudo dnf install glfw-devel

or

sudo pacman -S glfw-wayland # glfw-x11 for X11 users

GLM

Unlike DirectX 12, Vulkan does not include a library for linear algebra
operations, so we’ll have to download one. GLM is a
nice library that is designed for use with graphics APIs and is also commonly
used with OpenGL.

It is a header-only library that can be installed from the libglm-dev or
glm-devel package:

sudo apt install libglm-dev

or

sudo dnf install glm-devel

or

sudo pacman -S glm

Shader Compiler

We have just about all we need, except we’ll want a program to compile shaders from the human-readable GLSL to bytecode.

Two popular shader compilers are Khronos Group’s glslangValidator and Google’s glslc. The latter has a familiar GCC- and Clang-like usage, so we’ll go with that: on Ubuntu, download Google’s unofficial binaries and copy glslc to your /usr/local/bin. Note you may need to sudo depending on your permissions. On Fedora use sudo dnf install glslc, while on Arch Linux run sudo pacman -S shaderc. To test, run glslc and it should rightfully complain we didn’t pass any shaders to compile:

glslc: error: no input files

We’ll cover glslc in depth in the shader modules chapter.

Setting up a makefile project

Now that you have installed all of the dependencies, we can set up a basic
makefile project for Vulkan and write a little bit of code to make sure that
everything works.

Create a new directory at a convenient location with a name like VulkanTest.
Create a source file called main.cpp and insert the following code. Don’t
worry about trying to understand it right now; we’re just making sure that you
can compile and run Vulkan applications. We’ll start from scratch in the next
chapter.

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supportedn";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Next, we’ll write a makefile to compile and run this basic Vulkan code. Create a
new empty file called Makefile. I will assume that you already have some basic
experience with makefiles, like how variables and rules work. If not, you can
get up to speed very quickly with this tutorial.

We’ll first define a couple of variables to simplify the remainder of the file.
Define a CFLAGS variable that will specify the basic compiler flags:

CFLAGS = -std=c++17 -O2

We’re going to use modern C++ (-std=c++17), and we’ll set optimization level to O2. We can remove -O2 to compile programs faster, but we should remember to place it back for release builds.

Similarly, define the linker flags in a LDFLAGS variable:

LDFLAGS = -lglfw -lvulkan -ldl -lpthread -lX11 -lXxf86vm -lXrandr -lXi

The flag -lglfw is for GLFW, -lvulkan links with the Vulkan function loader and the remaining flags are low-level system libraries that GLFW needs. The remaining flags are dependencies of GLFW itself: the threading and window management.

It is possible that the Xxf68vm and Xi libraries are not yet installed on your system. You can find them in the following packages:

sudo apt install libxxf86vm-dev libxi-dev

or

sudo dnf install libXi-devel libXxf86vm-devel

or

sudo pacman -S libxi libxxf86vm

Specifying the rule to compile VulkanTest is straightforward now. Make sure to
use tabs for indentation instead of spaces.

VulkanTest: main.cpp
    g++ $(CFLAGS) -o VulkanTest main.cpp $(LDFLAGS)

Verify that this rule works by saving the makefile and running make in the
directory with main.cpp and Makefile. This should result in a VulkanTest
executable.

We’ll now define two more rules, test and clean, where the former will
run the executable and the latter will remove a built executable:

.PHONY: test clean

test: VulkanTest
    ./VulkanTest

clean:
    rm -f VulkanTest

Running make test should show the program running successfully, and displaying the number of Vulkan extensions. The application should exit with the success return code (0) when you close the empty window. You should now have a complete makefile that resembles the following:

CFLAGS = -std=c++17 -O2
LDFLAGS = -lglfw -lvulkan -ldl -lpthread -lX11 -lXxf86vm -lXrandr -lXi

VulkanTest: main.cpp
    g++ $(CFLAGS) -o VulkanTest main.cpp $(LDFLAGS)

.PHONY: test clean

test: VulkanTest
	./VulkanTest

clean:
    rm -f VulkanTest

You can now use this directory as a template for your Vulkan projects. Make a copy, rename it to something like HelloTriangle and remove all of the code in main.cpp.

You are now all set for the real adventure.

MacOS

These instructions will assume you are using Xcode and the Homebrew package manager. Also, keep in mind that you will need at least MacOS version 10.11, and your device needs to support the Metal API.

Vulkan SDK

The most important component you’ll need for developing Vulkan applications is the SDK. It includes the headers, standard validation layers, debugging tools and a loader for the Vulkan functions. The loader looks up the functions in the driver at runtime, similarly to GLEW for OpenGL — if you’re familiar with that.

The SDK can be downloaded from the LunarG website using the buttons at the bottom of the page. You don’t have to create an account, but it will give you access to some additional documentation that may be useful to you.

The SDK version for MacOS internally uses MoltenVK. There is no native support for Vulkan on MacOS, so what MoltenVK does is actually act as a layer that translates Vulkan API calls to Apple’s Metal graphics framework. With this you can take advantage of debugging and performance benefits of Apple’s Metal framework.

After downloading it, simply extract the contents to a folder of your choice (keep in mind you will need to reference it when creating your projects on Xcode). Inside the extracted folder, in the Applications folder you should have some executable files that will run a few demos using the SDK. Run the vkcube executable and you will see the following:

GLFW

As mentioned before, Vulkan by itself is a platform agnostic API and does not include tools for creation a window to display the rendered results. We’ll use the GLFW library to create a window, which supports Windows, Linux and MacOS. There are other libraries available for this purpose, like SDL, but the advantage of GLFW is that it also abstracts away some of the other platform-specific things in Vulkan besides just window creation.

To install GLFW on MacOS we will use the Homebrew package manager to get the glfw package:

brew install glfw

GLM

Vulkan does not include a library for linear algebra operations, so we’ll have to download one. GLM is a nice library that is designed for use with graphics APIs and is also commonly used with OpenGL.

It is a header-only library that can be installed from the glm package:

brew install glm

Setting up Xcode

Now that all the dependencies are installed we can set up a basic Xcode project for Vulkan. Most of the instructions here are essentially a lot of «plumbing» so we can get all the dependencies linked to the project. Also, keep in mind that during the following instructions whenever we mention the folder vulkansdk we are refering to the folder where you extracted the Vulkan SDK.

Start Xcode and create a new Xcode project. On the window that will open select Application > Command Line Tool.

Select Next, write a name for the project and for Language select C++.

Press Next and the project should have been created. Now, let’s change the code in the generated main.cpp file to the following code:

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>

#include <iostream>

int main() {
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow* window = glfwCreateWindow(800, 600, "Vulkan window", nullptr, nullptr);

    uint32_t extensionCount = 0;
    vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);

    std::cout << extensionCount << " extensions supportedn";

    glm::mat4 matrix;
    glm::vec4 vec;
    auto test = matrix * vec;

    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();

    return 0;
}

Keep in mind you are not required to understand all this code is doing yet, we are just setting up some API calls to make sure everything is working.

Xcode should already be showing some errors such as libraries it cannot find. We will now start configuring the project to get rid of those errors. On the Project Navigator panel select your project. Open the Build Settings tab and then:

• Find the Header Search Paths field and add a link to /usr/local/include (this is where Homebrew installs headers, so the glm and glfw3 header files should be there) and a link to vulkansdk/macOS/include for the Vulkan headers.
• Find the Library Search Paths field and add a link to /usr/local/lib (again, this is where Homebrew installs libraries, so the glm and glfw3 lib files should be there) and a link to vulkansdk/macOS/lib.

It should look like so (obviously, paths will be different depending on where you placed on your files):

Now, in the Build Phases tab, on Link Binary With Libraries we will add both the glfw3 and the vulkan frameworks. To make things easier we will be adding the dynamic libraries in the project (you can check the documentation of these libraries if you want to use the static frameworks).

• For glfw open the folder /usr/local/lib and there you will find a file name like libglfw.3.x.dylib («x» is the library’s version number, it might be different depending on when you downloaded the package from Homebrew). Simply drag that file to the Linked Frameworks and Libraries tab on Xcode.
• For vulkan, go to vulkansdk/macOS/lib. Do the same for the both files libvulkan.1.dylib and libvulkan.1.x.xx.dylib (where «x» will be the version number of the the SDK you downloaded).

After adding those libraries, in the same tab on Copy Files change Destination to «Frameworks», clear the subpath and deselect «Copy only when installing». Click on the «+» sign and add all those three frameworks here aswell.

Your Xcode configuration should look like:

The last thing you need to setup are a couple of environment variables. On Xcode toolbar go to Product > Scheme > Edit Scheme..., and in the Arguments tab add the two following environment variables:

• VK_ICD_FILENAMES = vulkansdk/macOS/share/vulkan/icd.d/MoltenVK_icd.json
• VK_LAYER_PATH = vulkansdk/macOS/share/vulkan/explicit_layer.d

It should look like so:

Finally, you should be all set! Now if you run the project (remembering to setting the build configuration to Debug or Release depending on the configuration you chose) you should see the following:

The number of extensions should be non-zero. The other logs are from the libraries, you might get different messages from those depending on your configuration.

You are now all set for the real thing.

Урок 50 — Введение в Vulkan

Думаю, вы как минимум слышали об Vulkan API —
новом графическом API от Khronos (некоммерческая организация разрабатывающая
OpenGL). Vulkan был анонсирован в феврале 2016, через 24 года после OpenGL, и
является полностью новым стандартом и уходом от текущей модели. Я не буду глубоко
вдаваться в отличия Vulkan, а только скажу, что он в разы более низкоуровневый
чем OpenGL, и даёт разработчику большой контроль над производительностью. Но с
большой силой приходит и большая ответственность. Разработчик должен взять под
контроль самые разные аспекты, например, буфер команд, синхронизацию и
управление памятью; ранее этим занимался драйвер. Но благодаря знанию структуры
приложения в деталях, разработчик может добиться максимальной производительности
используя Vulkan API нужным ему образом.

На мой взгляд, больше всего в Vulkan людей шокирует то, сколько требуется написать
кода просто для того, что бы вывести на экран первый треугольник. В первых уроках
по OpenGL для этого потребуется буквально пара строк, но здесь, для многих, желающих начать
цикл статей по Vulkan, это становится целым испытанием. Поэтому, как и всегда для
OGLDEV, я начну представлять материал по шагам. Мы выведем первый треугольник за
пару уроков, понемногу продвигаясь в каждом. Кроме того, я постараюсь не
вываливать дюжину вызовов API в одном длинном куске кода, а сразу начну
заворачивать в приложение с простым дизайном, который, я надеюсь, пригодится вам
для будущих приложений. Но в любом случае, это обучающее приложение, и не
стесняйтесь его изменять под себя.

Двигаясь по коду мы будем поочередно изучать ключевые компоненты Vulkan, поэтому
сейчас я просто хочу представить общую диаграмму:

Эта диаграмма ни в коем случае не претендует на полноту. Она содержит только
основные компоненты, которые будут использоваться в большинстве приложений. Связи
между компонентами обозначают зависимости в момент создания, либо перечисления.
Например, для создания поверхности требуется экземпляр объекта, а когда вы
перечисляете физические устройства системы, то также потребуется экземпляр. Два
цвета объясняют наш дизайн в общих чертах. Красный объединяет то, что я бы
назвал «ядром», а зелёный те части, которые будут «приложением». Позже мы
разберем для чего это нужно. Код самого приложения, которое вы будете писать,
будет наследоваться от «приложения», и все его части будут вам доступны для
использования. Очень надеюсь, что такой дизайн поможет нам в разработке следующих
частей этого цикла по Vulkan.

Подготовка системы

Первое что нам нужно, это проверить, что система поддерживает Vulkan, и
подготовить всё для разработки. Вы должны проверить, что ваша видеокарта поддерживает
Vulkan, и установить свежие драйвера. Так как Vulkan вышел в свет ещё совсем недавно,
то лучше проверять обновления драйверов как можно чаще, там могут быть исправления
ошибок. Поскольку существует огромное число GPU, я не могу подробно рассказать о
каждом. Обновление / установка драйверов под Windows не должна вызвать затруднений.
Под Linix могут потребоваться некоторые танцы с бубном. Для разработки я использую
Linux Fedora с видеокартой GT710 от NVIDIA на борту. NVIDIA предоставляет один
бинарный файл, который может быть установлен только из командной строки. У других
производителей всё может быть иначе. Под Linux вы можете использовать lspci для
скана системы и поиска своего GPU. Попробуйте добавить опции -v, -vv и -vvv
чтобы увидеть больше деталей.

Далее нам потребуется установить Vulkan SDK от компании Khronos, скачать который
можно по ссылке. SDK, помимо заголовочных файлов и
библиотек, включает в себя большое число примеров, которые вы можете использовать
для лучшего ознакомления с возможностями API. На момент написания урока актуальная
версия SDK 1.0.30.0, и я призываю вас регулярно проверять обновления, так как
SDK сейчас находится в активной разработке. В нескольких следующих разделах версия
будет указываться в командах в явном виде, так что не забывайте изменять её на
ту, которую вы устанавливаете.

Linux

Khronos предоставляет запускаемый файл предназначенный для Ubuntu. После запуска он
устанавливает всё что требуется, но при запуске под Fedora я столкнулся с некоторыми
сложностями. Я использовал следующие команды:

• bash$ chmod +x vulkansdk-linux-x86_64-1.0.30.0.run
• base$ ./vulkansdk-linux-x86_64-1.0.30.0.run –target VulkanSDK-1.0.30.0 –noexec
• base$ ln -s ~/VulkanSDK-1.0.30/1.0.30.0 ~/VulkanSDK

Эти команды извлекают содержимое пакета без запуска внутренних скриптов. После распаковки
директория VulkanSDK-1.0.30.0 будет содержать каталог 1.0.30.0 с файлами пакета.
Предположим, что я запускал эти команды находясь в домашнем каталоге (известном как ~),
тогда мы получим символьную ссылку ~/VulkanSDK на каталог с содержимым пакета (с
каталогами source, samples, и т.д.). Ссылка упрощает переключение среды разработки на
более свежую версию. По ссылке можно получить библиотеки и заголовочные файлы. Чуть позднее
мы разберемся с тем, как их использовать. А пока что сделайте следующее:

• bash$ cd VulkanSDK/1.0.30.0
• bash$ ./build_examples.sh

Если всё прошло успешно, то примеры были собраны в examples/build. Для их запуска вы должны
cd в этот каталог. А теперь попробуйте запустить ./cube и ./vulkaninfo чтобы убедиться,
что Vulkan запускается на вашей системе, и получить информацию о драйвере.

Надеюсь, что всё прошло успешно, так что мы можем добавить немного символических ссылок, чтобы
удобнее обращаться к файлам, которые нам требуются для разработки. Зайдите под суперпользователем
(с помощью вызова su и ввода пароля) и запустите команды:

• bash# ln -s /home/<your username>/VulkanSDK/x86_x64/include/vulkan /usr/include
• base# ln -s /home/<your username>/VulkanSDK/x86_x64/lib/libvulkan.so.1 /usr/lib64
• base# ln -s /usr/lib64/libvulkan.so.1 /usr/lib64/libvulkan.so

С помощью этих трёх команд мы добавили символические ссылки из /usr/include в каталог
заголовочных файлов Vulkan. Кроме того, мы добавили ссылки на динамические библиотеки,
которые будут использоваться при линковке. Теперь, если мы обновили SDK, то нам требуется только
изменить ссылку ~/VulkanSDK на местоположение новой версии. Отметим, что вызов команд из-под
рута требуется только один раз. После обновления SDK потребуется изменить ссылку только в
домашнем каталоге. Вы, конечно, можете дать ссылке любое имя, но код, который идет с
моими уроками, предполагает, что она находится в домашнем каталоге.

Windows

Установка под Windows ощутимо проще чем под Linux. Просто скачайте последнюю версию
здесь, дважды кликните по файлу установщика,
согласитесь со всем, что вам предложат, выберите директорию установки, и, в общем-то, всё.
Я бы предложил установить SDK в c:VulkanSDK для обеспечения совместимости с моим проектом
Visual Studio. Если вы устанавливаете куда-то ещё, то не забудьте обновить в проекте
директории с заголовочными файлами и библиотеками. Детали вы найдете в следующем разделе.

Сборка и запуск

Linux

Под Linux я в основном разрабатываю в Netbeans.
Код, который идет с уроками, содержит проекты сборки Netbeans для C/C++. Если
вы установили SDK как я написал выше, то эти проекты должны работать их коробки
(и, пожалуйста, сообщайте мне о любых проблемах). Если вы используете другую
систему сборки, убедитесь, что вы добавили:

• В команду компиляции: -I<path to VulkanSDK/1.0.30.0/x86_64/include>
• В команду линковки: -L<path to VulkanSDK/1.0.30.0/x86_64/lib> -lxcb -lvulkan’

Даже если вы не используете Netbeans, вы всё ещё можете скомпилировать урок
командой make. Netbeans самостоятельно генерирует Makefile. Этого будет
достаточно, чтобы проверить настройку системы. Для этого скачайте
исходники, разархивируйте их, зайдите в
каталог ogldev/tutorial50, а затем запустите команду make. Если вы всё
сделали правильно, то вы можете запустить dist/Debug/GNU-Linux-x86/tutorial50
из ogldev/tutorial50.

Windows

Если вы установили SDK в c:VulkanSDK, то мои проекты Visual Studio должны
работать прямо из коробки. Если же нет, или вы хотите создать новый проект
Visual Studio, то сделайте так:

Для обновления каталога с заголовочными файлами нажмите на проект в окошке
solution explorer, перейдите в Properties, а затем в
Configuration Properties -> C/C++ -> General. Теперь вы должны добавить
c:VulkanSDK<version>Include в Additional Include Directories.
Пример приведен ниже:

Для обновления каталога с файлами библиотеки нажмите правой кнопкой мыши на проект
в окошке solution explorer, перейдите в Properties и затем в
Configuration Properties -> Link -> General. Теперь вы должны добавить
c:VulkanSDK<version>Bin32 в поле Additional Library Directories.
Пример приведен ниже:

Пока вы ещё настраиваете линковщик зайдите в Input (сразу же под General), а
затем добавьте vulkan-1.lib в поле Additional Dependencies.

Общие комментарии

Прежде чем мы перейдем к коду, я бы хотел отметить некоторые мои решения о
дизайне приложений с использованием Vulkan.

1. Многие функции в Vulkan (особенно те, которые создают объекты) принимают на
   вход параметр — структуру. Такая структура используется как обертка над большей
   частью параметров, которые нужны функции. Благодаря этому у функций ощутимо меньше
   входящих параметров. Разработчики Vulkan решили, что первым параметром у таких
   структур будет свойство sType. Оно имеет перечислимый тип, и для каждой структуры
   свой код. Это позволяет драйверу определять тип структуры, зная только её адрес.
   У каждого кода есть префикс VK_STRUCTURE_TYPE_. Например, код структуры
   используемой при создании экземпляра VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO.

   Каждый раз когда я объявляю переменную с типом одной из этих структур, первое
   что я делаю, это обновляю значение sType. Для экономии бумаги в дальнейшем я
   не буду это упоминать.

2. Ещё одно важное замечание об этих структурах — у них очень много свойств,
   которые нас пока не волнуют. Что бы код был компактнее (а уроки короче…) я
   всегда буду инициализировать структуры нулями (с помощью нотации struct = {})
   и в явном виде обозначать только те свойства, которые не могут быть нулями.
   Я объясню их в следующих уроках, когда эти свойства будут востребованы.

3. В Vulkan функции либо являются процедурами, либо возвращают код ошибки в объекте
   VkResult. Код ошибки является перечислением, где VK_SUCCESS равно 0,
   а все остальные коды ошибок больше 0. По мере возможностей я добавляю проверку на
   ошибки. Если возникла ошибка, то я вывожу сообщение в консоль (а в Window в отдельном
   окошке) и выхожу. Обработка ошибок в реальном приложении слишком усложняет код, а
   моя задача сохранить простоту.

4. Многие функции Vulkan (особенно те, которые создают объекты) принимают на вход
   функцию выделения памяти. Такой подход позволяет контролировать процесс выделения
   памяти Vulkan. На мой взгляд это тема для уже опытных разработчиков, поэтому мы
   не будем заморачиваться с этим и всегда будем передавать NULL. В этом случае
   драйвер будет использовать свою функцию по умолчанию.

5. Vulkan не гарантирует экспорт своих функций в библиотеке. Это значит, что на
   некоторых платформах вы можете получить segmentation fault при вызове функции
   Vulkan так как она оказалась равна NULL. В этом случае вы вынуждены использовать
   vkGetInstanceProcAddr() для получения адреса функции перед её использованием
   (вспомним, что в OpenGL для этой проблемы мы использовали GLEW). В моем случае
   только vkCreateDebugReportCallbackEXT() была не доступна. Эта функция требуется
   только для дополнительной проверочной прослойки. Поэтому, я решил рискнуть и
   для всех функций которые я использую в уроке не получать адресов. Если поступят
   жалобы, то я обновлю код урока.

6. Каждое серьезное приложение обязано позаботиться об освождении память, иначе
   не избежать утечек. В этом уроке я не стал усложнять и не уничтожаю никакие
   объекты. В любом случае они удалятся при завершении программы. В будущем я,
   возможно, ещё вернусь к этой теме, но пока просто запомните, что почти все
   функции вида <vkCreate()** имеют в пару **vkDestroy(). И будьте
   осторожны при удалении объектов пока программа ещё работает. Больше деталей вы
   найдете по ссылке.

Структура проекта

Далее приведен краткий перечень файлов, которые мы собираемся обозревать.

1. tutorial50/tutorial50.cpp — здесь определена функция main().

2. include/ogldev_vulkan.h — основной заголовочный и единственный файл в
   котором загружаются заголовочные файлы Vulkan. Вы можете включить проверочную
   прослойку раскоментив ENABLE_DEBUG_LAYERS. Этот файл содержит несколько
   вспомогательных функций и макросов, а так же определение класса VulkanWindowControl.

3. Common/ogldev_vulkan.cpp — реализация функций, определённых в ogldev_vulkan.h.

4. include/ogldev_vulkan_core.h — объявление главного класса OgldevVulkanCore в
   котором сосредоточена вся суть.

5. Common/ogldev_vulkan_core.cpp — реализация класса OgldevVulkanCore.

6. include/ogldev_xcb_control.h — объявление класса XCBControl, который
   создает окно в Linux.

7. Common/ogldev_xcb_control.cpp — реализация XCBControl.

8. include/ogldev_win32_control.h — объявление класса Win32Control, который
   создает окно в Windows.

9. Common/ogldev_win32_control.cpp — реализация Win32Control.

Как в Netbeans, так и в Visual Studio файлы разделены между проектами tutorial50 и Common.

Прямиком к коду!

Я надеюсь, что вы справились с первой частью и теперь полностью готовы
погрузиться в Vulkan. Как я уже говорил, мы собираемся разработать наше первое
демо приложение в несколько этапов. Первым шагом будет настроить самые основные
объекты Vulkan: экземпляр, поверхность, физическое и логическое устройства.
Я буду объяснять следуя моему дизайну приложения, но вы вольны пропустить эту
часть и изучать только обращения к Vulkan.

В самом начале мы включаем заголовки Vulkan. В моем проекте все файлы Vulkan
включаются только в файле ogldev_vulkan.h. Поэтому во всём остальном проекте
включается только этот файл. Вот соответствующие куски кода:

#ifdef _WIN32
#define VK_USE_PLATFORM_WIN32_KHR
#include "vulkan/vulkan.h"
#include "vulkan/vk_sdk_platform.h"
#else
#define VK_USE_PLATFORM_XCB_KHR
#include <vulkan/vulkan.h>
#include <vulkan/vk_sdk_platform.h>
#endif

Обратите внимание на то, что мы добавили различные макросы для Windows и Linux.
Эти макросы включают дополнения для поддержки оконной системы для каждой ОС.
Причина, по которой включение заголовков отличается кавычками, в том, что в
Linux эти файлы устанавливаются в системный каталог (/usr/include/vulkan),
а в Windows в стандартный каталог.

Давайте начнем обзор с класса OgldevVulkanCore, который отвечает за создание
и работу с основными объектами.

class OgldevVulkanCore
{
public:
    OgldevVulkanCore(const char* pAppName);
    ~OgldevVulkanCore();

    bool Init(VulkanWindowControl* pWindowControl);

    const VkPhysicalDevice& GetPhysDevice() const;

    const VkSurfaceFormatKHR& GetSurfaceFormat() const;

    const VkSurfaceCapabilitiesKHR GetSurfaceCaps() const;

    const VkSurfaceKHR& GetSurface() const { return m_surface; }

    int GetQueueFamily() const { return m_gfxQueueFamily; }

    VkInstance& GetInstance() { return m_inst; }

    VkDevice& GetDevice() { return m_device; }

private:
    void CreateInstance();
    void CreateSurface();
    void SelectPhysicalDevice();
    void CreateLogicalDevice();

    // Объекты Vulkan
    VkInstance m_inst;
    VkDevice m_device;
    VkSurfaceKHR m_surface;
    VulkanPhysicalDevices m_physDevices;

    // Внутрение детали
    std::string m_appName;
    int m_gfxDevIndex;
    int m_gfxQueueFamily;
};

Помимо вектора объектов Vulkan m_physDevices (инициирован будет далее), класс
включает в себя три свойства Vulkan (m_inst, surface и m_device). Кроме
того, мы храним название приложения, индекс используемого физического устройства и
индекс набора очередей. Класс также содержит несколько методов чтения и функцию Init(), которая всё настраивает.
Давайте разберёмся, что же она делает.

void OgldevVulkanCore::Init(VulkanWindowControl* pWindowControl)
{
    std::vector<VkExtensionProperties> ExtProps;
    VulkanEnumExtProps(ExtProps);

    CreateInstance();

    #ifdef WIN32
    assert(0);
    #else
    m_surface = pWindowControl->CreateSurface(m_inst);
    assert(m_surface);
    #endif
    printf("Surface createdn");

    VulkanGetPhysicalDevices(m_inst, m_surface, m_physDevices);
    SelectPhysicalDevice();
    CreateLogicalDevice();
}

Эта функция принимает на вход объект VulkanWindowControl. Мы потом разберёмся с этим
объектом. Пока что достаточно сказать, что это ОС зависимый класс, задача которого — это
создание оконной поверхности, на которую будет происходить рендер. Совсем как и в OpenGL,
ядро Vulkan не содержит работы с окнами. Эта задача отдана расширениям, и у нас есть
полный набор для всех основных ОС. Участники Khronos могут публиковать свои собственные
расширения в общем регистре. Разработчики
драйверов сами решают какие из разрешений они хотят реализовывать. А уже пользователи
Vulkan могут во время работы приложения смотреть в список доступных разрешений и
решать что с ними делать.

Мы начнем с перечисления всех расширений. Происходит это в следующей функции —
декораторе:

void VulkanEnumExtProps(std::vector<vkextensionproperties>& ExtProps)
{
    uint NumExt = 0;
    VkResult res = vkEnumerateInstanceExtensionProperties(NULL, &NumExt, NULL);
    CHECK_VULKAN_ERROR("vkEnumerateInstanceExtensionProperties error %dn", res);

    printf("Found %d extensionsn", NumExt);

    ExtProps.resize(NumExt);

    res = vkEnumerateInstanceExtensionProperties(NULL, &NumExt, &ExtProps[0]);
    CHECK_VULKAN_ERROR("vkEnumerateInstanceExtensionProperties error %dn", res);

    for (uint i = 0 ; i < NumExt ; i++) {
        printf("Instance extension %d - %sn", i, ExtProps[i].extensionName);
    }
}

Функция выше обрамляет вызов vkEnumerateInstanceExtensionProperties() к
Vulkan API, который возвращает доступные в системе расширения. То, как мы
используем это функцию, очень распространённая методика в Vulkan. Первый вызов возвращает
количество расширений. Это число мы используем для задания размера вектора
расширений. Второй вызов уже возвращает сами расширения. Первый параметр
позволяет выбрать прослойку. Vulkan устроен таким образом, что производители
видеокарт могут добавлять логические прослойки для валидации, дополнительной
отладочной печати и другие. Во время работы приложения мы вольны выбирать, какой
из слоев включить. Например, во время разработки включить слой с проверками
данных, а в готовой версии приложения уже отключать. Так как нам нужны
все расширения, то мы передаем NULL в качестве слоя.

После получения списка расширений мы печатаем их. Если вы хотите произвести
какие-то действия со списком расширений, то эту логику можно добавить сюда.
Печать списка расширений позволит убедиться в том, что требуемые далее
расширения включены в этот список. Следующий этап инициализации заключается
в создании экземпляра Vulkan:

void OgldevVulkanCore::CreateInstance()
{
    VkApplicationInfo appInfo = {};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName = m_appName.c_str();
    appInfo.engineVersion = 1;
    appInfo.apiVersion = VK_API_VERSION_1_0;

    const char* pInstExt[] = {
#ifdef ENABLE_DEBUG_LAYERS
        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
#endif
        VK_KHR_SURFACE_EXTENSION_NAME,
#ifdef _WIN32
        VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
#else
        VK_KHR_XCB_SURFACE_EXTENSION_NAME
#endif
    };

#ifdef ENABLE_DEBUG_LAYERS
    const char* pInstLayers[] = {
        "VK_LAYER_LUNARG_standard_validation"
    };
#endif

    VkInstanceCreateInfo instInfo = {};
    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    instInfo.pApplicationInfo = &appInfo;
#ifdef ENABLE_DEBUG_LAYERS
    instInfo.enabledLayerCount = ARRAY_SIZE_IN_ELEMENTS(pInstLayers);
    instInfo.ppEnabledLayerNames = pInstLayers;
#endif
    instInfo.enabledExtensionCount = ARRAY_SIZE_IN_ELEMENTS(pInstExt);
    instInfo.ppEnabledExtensionNames = pInstExt;

    VkResult res = vkCreateInstance(&instInfo, NULL, &m_inst);
    CHECK_VULKAN_ERROR("vkCreateInstance %dn", res);

#ifdef ENABLE_DEBUG_LAYERS
    // Получаем адрес функции vkCreateDebugReportCallbackEXT
    my_vkCreateDebugReportCallbackEXT = reinterpret_cast<pfn_vkcreatedebugreportcallbackext>(vkGetInstanceProcAddr(m_inst, "vkCreateDebugReportCallbackEXT"));

    // Регистрируем функцию отладки
    VkDebugReportCallbackCreateInfoEXT callbackCreateInfo;
    callbackCreateInfo.sType       = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
    callbackCreateInfo.pNext       = NULL;
    callbackCreateInfo.flags       = VK_DEBUG_REPORT_ERROR_BIT_EXT |
                                     VK_DEBUG_REPORT_WARNING_BIT_EXT |
                                     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
    callbackCreateInfo.pfnCallback = &MyDebugReportCallback;
    callbackCreateInfo.pUserData   = NULL;

    VkDebugReportCallbackEXT callback;
    res = my_vkCreateDebugReportCallbackEXT(m_inst, &callbackCreateInfo, NULL, &callback);
    CheckVulkanError("my_vkCreateDebugReportCallbackEXT error %dn", res);
#endif
}

Для инициализации библиотеки Vulkan мы должны создать экземпляр — объект
VkInstance. Этот объект хранит состояние приложения. Функция, которая
создает его, называется vkCreateInstance(), и ей требуется большая часть
свойств структуры VkInstanceCreateInfo. Интересующие нас параметры, это
список расширений и (дополнительно) список слоев, которые мы хотим включить.
Из расширений это расширение общей поверхности и расширение для ОС зависимой
поверхности. Слои и расширения определяются через их название — строку, а для
некоторых из них Khronos SDK предлагает макрос. VkInstanceCreateInfo также
принимает указатель на структуру VkApplicationInfo. Эта структура содержит
свойства приложения, а разработчик может задать название и некоторую
внутреннюю версию движка. Свойство VkApplicationInfo, на которое стоит обратить
внимание, это apiVersion. Это задает минимальную версию Vulkan, которая
требуется приложению. Если в системе установлена версия меньше, то этот
вызов бросит ошибку. Мы запрашиваем версию 1.0, так что всё должно быть в порядке.

После того как в наши руки попадёт экземпляр мы сможем зарегистрировать в
проверяющим слое функцию, которая будет печатать предупреждения и сообщения об
ошибках. Для этого получаем указатель на функцию vkCreateDebugReportCallbackEXT,
затем мы заполняем структуру VkDebugReportCallbackCreateInfoEXT флагами о
тех аспектах, о которых драйвер должен нас уведомлять, и указателем на нашу
функцию отладки. В действительности регистрация происходит при вызове функции,
указатель на которую мы получили ранее. Мы получаем указатель на функцию
vkCreateDebugReportCallbackEXT и наша функция обратного вызова для отладки
имеет следующий вид:

PFN_vkCreateDebugReportCallbackEXT my_vkCreateDebugReportCallbackEXT = NULL;

VKAPI_ATTR VkBool32 VKAPI_CALL MyDebugReportCallback(
    VkDebugReportFlagsEXT       flags,
    VkDebugReportObjectTypeEXT  objectType,
    uint64_t                    object,
    size_t                      location,
    int32_t                     messageCode,
    const char*                 pLayerPrefix,
    const char*                 pMessage,
    void*                       pUserData)
{
    printf("%sn", pMessage);
    return VK_FALSE;    // Т.к. мы не хотим чтобы вызывающая функция упала.
}

Далее мы создадим оконную поверхность. Для этого мы воспользуемся объектом
VulkanWindowControl, указатель на который получает функция Init(). С этим
классом мы познакомимся позднее, поэтому не будем на нём сейчас останавливаться
(обратите внимание на то, что для создания поверхности используется экземпляр;
поэтому мы и создаём объекты в этом порядке).

После создания экземпляра и поверхности мы готовы к получению информации о
физических устройствах системы. Под физическим устройством мы понимаем либо
дискретную, либо интегрированную видеокарту. Например, ваш компьютер может
иметь две видеокарты NVIDIA с технологией SLI и графический GPU Intel HD,
встроенный в CPU. В этом случае у вас три физических устройства. Функция ниже
получает все физические устройства и некоторые их характеристики в виде
структуры VulkanPhysicalDevices. Структура, по сути, представляет собой
базу данных физических устройств и их свойств. Она состоит из нескольких
векторов (иногда векторов векторов) объектов Vulkan. Для получения доступа к
конкретному устройству вы должны получить индекс устройства и с ним обращаться
к вектору. То есть, для получения информации о физическом устройстве с индексом
2 обращайтесь к m_device[2] и m_devProps[2], и так далее. Причина, по
которой я выбрал такую структуру (а не один объект на устройство), в том, что
это совпадает с форматом API Vulkan. Вы предоставляете массив XYZ и получаете
все XYZ объекты для всех физических устройств. Вот определение этой схожей
с базой данных структуры:

struct VulkanPhysicalDevices {
    std::vector<VkPhysicalDevice> m_devices;
    std::vector<VkPhysicalDeviceProperties> m_devProps;
    std::vector< std::vector<VkQueueFamilyProperties> > m_qFamilyProps;
    std::vector< std::vector<VkBool32> > m_qSupportsPresent;
    std::vector< std::vector<VkSurfaceFormatKHR> > m_surfaceFormats;
    std::vector<VkSurfaceCapabilitiesKHR> m_surfaceCaps;
};

Теперь давайте рассмотрим функцию заполнения базы данных. Первых два параметра
представляют собой экземпляр и поверхность. Третий параметр это то, куда будут
записаны данные. Мы будем изучать функцию по частям.

void VulkanGetPhysicalDevices(const VkInstance& inst, const VkSurfaceKHR& Surface, VulkanPhysicalDevices& PhysDevices)
{
    uint NumDevices = 0;

    VkResult res = vkEnumeratePhysicalDevices(inst, &NumDevices, NULL);
    CHECK_VULKAN_ERROR("vkEnumeratePhysicalDevices error %dn", res);
    printf("Num physical devices %dn", NumDevices);

Вначале мы должны получить число физических устройств. И снова мы видим систему
из двух вызовов — первый для получения количества элементов, а второй для
получения уже самих значений.

    PhysDevices.m_devices.resize(NumDevices);
    PhysDevices.m_devProps.resize(NumDevices);
    PhysDevices.m_qFamilyProps.resize(NumDevices);
    PhysDevices.m_qSupportsPresent.resize(NumDevices);
    PhysDevices.m_surfaceFormats.resize(NumDevices);
    PhysDevices.m_surfaceCaps.resize(NumDevices);

Мы можем изменить размер базы данных таким образом, чтобы вмещать все элементы.

    res = vkEnumeratePhysicalDevices(inst, &NumDevices, &PhysDevices.m_devices[0]);
    CHECK_VULKAN_ERROR("vkEnumeratePhysicalDevices error %dn", res);

И ещё раз этот вызов, но уже с адресом вектора VkPhysicalDevice. Очень удобно
использовать векторы из стандартной библиотеки, так как они функционируют как
обычные массивы — адрес первого элемента и есть адрес самого вектора. С нашей
точки зрения VkPhysicalDevice представляет собой идентификатор физического
устройства. Давайте теперь составим цикл по числу физических устройств и для
каждого из них получим больше информации.

    for (uint i = 0 ; i < NumDevices ; i++) {
        const VkPhysicalDevice& PhysDev = PhysDevices.m_devices[i];
        vkGetPhysicalDeviceProperties(PhysDev, &PhysDevices.m_devProps[i]);

Мы начинаем с получения свойств текущего устройства. m_devProps — это вектор
VkPhysicalDeviceProperties. Эта структура содержит такую информацию об
устройстве, как название, версия, ID и прочее. При помощи следующих вызовов
printf мы выводим на печать некоторые из этих свойств:

        printf("Device name: %sn", PhysDevices.m_devProps[i].deviceName);
        uint32_t apiVer = PhysDevices.m_devProps[i].apiVersion;
        printf("    API version: %d.%d.%dn", VK_VERSION_MAJOR(apiVer),
                                          VK_VERSION_MINOR(apiVer),
                                          VK_VERSION_PATCH(apiVer));

После этого мы получаем свойства всех наборов очередей, которые есть у устройства.
GPU может выполнять всего четыре вида операций:

1. Графические — 2D/3D рендер (как и OpenGL).

2. Вычисление — общий вычислительный процесс, который никак не связан с рендером.
   Используется, например, для параллельных вычислений, без какого-либо отношения
   к 3D.

3. Перемещение — копирование буферов и изображений.

4. Управление фрагментированной памятью, т.е. которая не смежна. Эти команды
   помогают разобраться с ней.

Задачи, которые мы отправляем устройству, выполняются по очереди. Устройство
предоставвляет один или несколько наборов очередей, и каждый из них содержит
одну и более очередей. У каждого набора своя комбинация из четырёх типов
приведенных выше. Очереди в каждом наборе имеют общую функциональность.
Например, мой GPU имеет два набора: первый состоит из 16 очередей и принимает
все четыре типа команд. А второй только из одной очереди, которая поддерживает
лишь перемещение. Это полезно для архитектурно-зависимых трюков по улучшению
производительности приложения.

        uint NumQFamily = 0;

        vkGetPhysicalDeviceQueueFamilyProperties(PhysDev, &NumQFamily, NULL);

        printf("    Num of family queues: %dn", NumQFamily);

        PhysDevices.m_qFamilyProps[i].resize(NumQFamily);
        PhysDevices.m_qSupportsPresent[i].resize(NumQFamily);

        vkGetPhysicalDeviceQueueFamilyProperties(PhysDev, &NumQFamily, &(PhysDevices.m_qFamilyProps[i][0]));

В коде выше мы получили число свойств у набора текущего устройства, изменили
размер m_qFamilyProps и m_qSupportsPresent (оба являются векторами векторов,
так что мы обязаны сначала выбрать текущее устройство), а затем мы получили и
записали в базу вектор свойств.

        for (uint q = 0 ; q < NumQFamily ; q++) {
            res = vkGetPhysicalDeviceSurfaceSupportKHR(PhysDev, q, Surface, &(PhysDevices.m_qSupportsPresent[i][q]));
            CHECK_VULKAN_ERROR("vkGetPhysicalDeviceSurfaceSupportKHR error %dn", res);
        }

Пока мы ещё говорим про наборы очередей, давайте пройдёмся по каждому набору и
проверим, поддерживает ли он вывод на экран. vkGetPhysicalDeviceSurfaceSupportKHR()
принимает на вход физическое устройство, поверхность, индекс набора очередей и
возвращает флаг — может ли такая комбинация из устройства и набора выводить на
поверхность.

        uint NumFormats = 0;
        vkGetPhysicalDeviceSurfaceFormatsKHR(PhysDev, Surface, &NumFormats, NULL);
        assert(NumFormats > 0);

        PhysDevices.m_surfaceFormats[i].resize(NumFormats);

        res = vkGetPhysicalDeviceSurfaceFormatsKHR(PhysDev, Surface, &NumFormats, &(PhysDevices.m_surfaceFormats[i][0]));
        CHECK_VULKAN_ERROR("vkGetPhysicalDeviceSurfaceFormatsKHR error %dn", res);

        for (uint j = 0 ; j < NumFormats ; j++) {
            const VkSurfaceFormatKHR& SurfaceFormat = PhysDevices.m_surfaceFormats[i][j];
            printf("    Format %d color space %dn", SurfaceFormat.format , SurfaceFormat.colorSpace);
        }

На очереди формат поверхности. Каждая поверхность поддерживает не менее одного
формата. Формат просто определяет то, как данных используются поверхностью.
В целом, формат указывает на каналы каждого пикселя и тип канала
(float, int, …). Например, VK_FORMAT_R32G32B32_SFLOAT задает три канала
(красный, зелёный и синий) из 32-х битного типа с плавающей запятой. Формат
поверхности очень важен так как он определяет то, как данные будут использоваться
или конвертироваться в различных операциях (например отображение на экран).
Для получения формата нам нужны как поверхность, так и физическое устройство
так как они могут получиться несовместимыми. Мы снова используем вектор векторов
поскольку форматов поверхностей может быть доступно сразу несколько штук.
Формат нам понадобится позже, поэтому сейчас мы записываем его в базу данных.
Теперь давайте получим свойства поверхности:

        res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(PhysDev, Surface, &(PhysDevices.m_surfaceCaps[i]));
        CHECK_VULKAN_ERROR("vkGetPhysicalDeviceSurfaceCapabilitiesKHR error %dn", res);

        VulkanPrintImageUsageFlags(PhysDevices.m_surfaceCaps[i].supportedUsageFlags);
    }
}

Структура VkSurfaceCapabilitiesKHR описывает свойства физического устройства
в рамках конкретной поверхности. Они включают в себя минимальное и максимальное
количество изображений, которые могут входить в цепочку изображений,
минимальный и максимальный размер участка, который может быть отрендерен,
поддерживаемые повороты и прочее. Для каждой пары физического устройства и
поверхности у нас по одной структуре, все они хранятся в векторе m_surfaceCaps.

Ух, наконец-то мы получили всю информацию о физических устройствах! (Ещё раз,
некоторые из этих свойств зависят от выбранной поверхности). Следующий шаг в
функции Init() — это выбор одного из физических устройств и одной из очередей
для начала обработки. Следующая функция занимается как раз этим:

void OgldevVulkanCore::SelectPhysicalDevice()
{
    for (uint i = 0 ; i < m_physDevices.m_devices.size() ; i++) {

        for (uint j = 0 ; j < m_physDevices.m_qFamilyProps[i].size() ; j++) {
            VkQueueFamilyProperties& QFamilyProp = m_physDevices.m_qFamilyProps[i][j];

            printf("Family %d Num queues: %dn", j, QFamilyProp.queueCount);
            VkQueueFlags flags = QFamilyProp.queueFlags;
            printf("    GFX %s, Compute %s, Transfer %s, Sparse binding %sn",
                    (flags & VK_QUEUE_GRAPHICS_BIT) ? "Yes" : "No",
                    (flags & VK_QUEUE_COMPUTE_BIT) ? "Yes" : "No",
                    (flags & VK_QUEUE_TRANSFER_BIT) ? "Yes" : "No",
                    (flags & VK_QUEUE_SPARSE_BINDING_BIT) ? "Yes" : "No");

            if (flags & VK_QUEUE_GRAPHICS_BIT) {
                if (!m_physDevices.m_qSupportsPresent[i][j]) {
                    printf("Present is not supportedn");
                    continue;
                }

                m_gfxDevIndex = i;
                m_gfxQueueFamily = j;
                printf("Using GFX device %d and queue family %dn", m_gfxDevIndex, m_gfxQueueFamily);
                break;
            }
        }
    }

    if (m_gfxDevIndex == -1) {
        printf("No GFX device found!n");
        assert(0);
    }
}

В более сложных приложениях вам могут понадобиться несколько очередей на
нескольких устройствах, но пока давайте сделаем проще. Вложенный цикл в этой
функции проходит по списку устройств и списку наборов очередей для каждого
устройства. Мы ищем устройство и очередь, которые поддерживают графические
команды и способны вывести графику на ту поверхность, для которой была заполнена
база данных. Когда мы найдем подходящее устройство и набор, мы сохраним их
индексы и выйдем из цикла. Эта пара из устройства и набора будет использоваться
на протяжении всего урока. Если подходящей пары не найдено, то приложение
будет завершено. Это означает, что система не удовлетворяем минимальным
требованиям для работы приложения.

Всё что нам осталось, это инициализировать ядро и создать логическое устройство:

void OgldevVulkanCore::CreateLogicalDevice()
{
    float qPriorities = 1.0f;
    VkDeviceQueueCreateInfo qInfo = {};
    qInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    qInfo.queueFamilyIndex = m_gfxQueueFamily;
    qInfo.queueCount = 1;
    qInfo.pQueuePriorities = &qPriorities;

    const char* pDevExt[] = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
    };

    VkDeviceCreateInfo devInfo = {};
    devInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    devInfo.enabledExtensionCount = ARRAY_SIZE_IN_ELEMENTS(pDevExt);
    devInfo.ppEnabledExtensionNames = pDevExt;
    devInfo.queueCreateInfoCount = 1;
    devInfo.pQueueCreateInfos = &qInfo;

    VkResult res = vkCreateDevice(GetPhysDevice(), &devInfo, NULL, &m_device);

    CHECK_VULKAN_ERROR("vkCreateDevice error %dn", res);

    printf("Device createdn");
}

Vulkan разделяет понятия физического устройства, как части реальной системы, от
логического устройства как абстракции над ним. Логическое устройство — это то,
что используется в приложении для создания большей части объектов зависящих от
устройства (очереди, цепочки изображений и прочее). Такая архитектура добавляет
гибкости в управлении устройствами. Логическое устройство позволяет нам давать
доступ только к отдельным аспектам физического устройства. Например, если
физическое устройство поддерживает и графику и вычисления, то мы можем дать
доступ только к графике через логическое устройство.

Для создания устройства нам понадобится одна структура VkDeviceCreateInfo и
ещё одна VkDeviceQueueCreateInfo. VkDeviceCreateInfo главная часть
определения устройства. В этой структуре мы назначаем указатель на массив
расширений, которые хотим использовать. Нам нужно включить цепочки изображений,
так как они определены в расширениях, а не в ядре. Цепочка изображений — это
массив изображений поверхностей, которые могут быть нарисованы. Нам также нужен
размер массива расширений. Далее нам нужен указатель на массив структур
VkDeviceQueueCreateInfo (и его размер). Для каждого набора очередей, который
мы хотим использовать, потребуется одна структура VkDeviceQueueCreateInfo.
Эта структура содержит индекс набора очередей (который мы получили ранее в
SelectPhysicalDevice()), число требуемых нам очередей, и для каждой очереди
мы можем указать приоритет. В этом уроке мы не будем задавать приоритеты, т.к.
очередь у нас одна и приоритет у неё 1.0.

На этом завершается инициализация класса OgldevVulkanCore, но для вызова
метода Init() нам нужен VulkanWindowControl — класс, который я добавил
для декорации управления оконной поверхности. Вспомним, что эта часть не относится
к ядру Vulkan, и так как для каждой ОС требуется свой код, то я решил разделить
на классы всю работу с окнами. Сам класс является интерфейсом и определён
следующим образом:

class VulkanWindowControl
{
protected:
    VulkanWindowControl() {};

    ~VulkanWindowControl() {};

public:

    virtual bool Init(uint Width, uint Height) = 0;

    virtual VkSurfaceKHR CreateSurface(VkInstance& inst) = 0;
};

Как вы можете заметить, этот класс крайне прост. У него нет никаких свойств.
Так как его конструктор и деструктор имеют модификатор доступа protected,
то нельзя создать экземпляры этого класса напрямую. Есть два публичных
метода. Один для инициализации объекта, и второй для создания поверхности Vulkan.
Таким образом для каждой ОС мы вольны в своих действиях, главное — это вернуть
объект VkSurfaceKHR. Таким образом, мы можем инициализировать этот класс перед
созданием VulkanCoreObject, но нам требуется инициализировать
VulkanCoreObject до вызова CreateSurface(). Не волнуйтесь, мы к этому ещё
вернемся при разборе функции main().

Реализаций класса VulkanWindowControl всего две: XCBControl для Linux и
Win32Control для Windows. Сначала мы рассмотрим версию для Linux.

class XCBControl : public VulkanWindowControl
{
public:
    XCBControl();

    ~XCBControl();

    virtual bool Init(uint Width, uint Height);

    virtual VkSurfaceKHR CreateSurface(VkInstance& inst);

 private:
    xcb_connection_t* m_pXCBConn;
    xcb_screen_t* m_pXCBScreen;
    xcb_window_t m_xcbWindow;
};

Самая популярная оконная система на Linux — это, конечно же, XWindow. Она
работает в клиент — серверной архитектуре. Сервер управляет экраном, клавиатурой
и мышью. Клиентами являются приложения, которые хотят что-то вывести на экран.
Они подключаются к серверу по протоколу X11 и отправляют запросы на создание
окна, управление клавиатурой / мышью и прочее. Самыми часто встречаемыми
реализациями протокола X11 являются Xlib и XCB, и они обе поддерживаются Vulkan.
XCB более современная, поэтому мы будем
использовать её под Linux. XCBControl реализует класс VulkanWindowControl
используя вызовы XCB. Напомню, что целью всего этого является создание окна ОС
и подсоединение его к поверхности Vulkan. В результате Vulkan должен быть
способен рендерить в это окно. Давайте начнем с создания окна:

void XCBControl::Init(uint Width, uint Height)
{
    m_pXCBConn = xcb_connect(NULL, NULL);

    int error = xcb_connection_has_error(m_pXCBConn);

    if  (error) {
        printf("Error opening xcb connection error %dn", error);
        assert(0);
    }

    printf("XCB connection openedn");

Первое что нам потребуется сделать — это подключиться к серверу XWindow. Я
уверен что вы используете графический режим, поэтому сервер уже запущен в
фоне. xcb_connect() открывает подключение к серверу. Она принимает два
параметра: название сервера и указатель на желаемый номер экрана (его для
нас заполнит библиотека XCB). XWindow очень гибок в настройке. Например, он
позволяет запустить сервер на одной машине, а клиента на другой. А можно
запустить сразу несколько серверов на одной машине. Для подключения к удаленному
серверу потребуется его IP и номер экрана в специальном формате строки. А для
запуска локально достаточно передать NULL в оба параметра.

Мы сохраняем в классе указатель на подключение, которое возвращает
xcb_connect(). Функция всегда что-то возвращает, поэтому мы обязательно
проверяем наличие ошибок с помощью функции xcb_connectionn_has_error() как
показано выше.

    const xcb_setup_t *pSetup = xcb_get_setup(m_pXCBConn);

    xcb_screen_iterator_t iter = xcb_setup_roots_iterator(setup);

    m_pXCBScreen = iter.data;

    printf("XCB screen %pn", m_pXCBScreen);

Сервер XWindow может управлять несколькими мониторами и запускать несколько
экранов на каждом из них. Как раз на экране и запускаются приложения. Он имеет
ширину, высоту, грубину цвета и прочие характеристики. Мы хотим получить доступ
к текущему экрану, для чего нам потребуются два действия. Первое — это
использовать функцию xcb_get_setup() для доступа к структуре xcb_setup_t
с данными о соединении. В ней содержится большое количество информации о
сервере. Среди прочего там есть список экранов. Для доступа к этому списку мы
создаем итератор с помощью функции xcb_setup_roots_iterator(). В сложных
приложениях тут должен быть код, который пробегает по списку экранов в поиске
подходящего для приложения. А мы просто возьмём первый в списке. Экран можно
получить следующим образом:

    m_xcbWindow = xcb_generate_id(m_pXCBConn);

Теперь мы готовы к созданию окна. Первым шагом мы генерируем XID — беззнаковое
целое число, идентификатор всех ресурсов XWindow. Когда клиент подсоединяется к
серверу, последний выделяет подмножество XID для этого клиента. Когда клиент
хочет создать некоторый объект на сервере, он выделяет себе XID из разрешенного
ему промежутка. Последующие вызовы функций могут использовать полученный XID.
Это довольно интересный подход. Обычно сервер говорит «эй, вот тебе новый объект и
его номер XYZ». А здесь клиент говорит «слушай, сервер, я хочу создать новый
объект и вот его номер». xcb_generate_id() генерирует XID для окна, а мы
сохраняем его в свойство m_xcbWindow.

    xcb_create_window(m_pXCBConn,             // соединение с сервером XWindow
      XCB_COPY_FROM_PARENT,                   // глубина цвета
      m_xcbWindow,                            // XID нового окна
      m_pXCBScreen->root,                     // родительское окно
      0,                                      // координата X
      0,                                      // координата Y
      Width,                                  // ширина окна
      Height,                                 // высота окна
      0,                                      // ширина границы
      XCB_WINDOW_CLASS_INPUT_OUTPUT,          // класс окна, не смог найти документации
      m_pXCBScreen->root_visual,              // определяет отображения цвета
      0,
      0);

Функция xcb_create_window(), которая создает окно, принимает, ни много ни
мало, 13 параметров. Я добавил немного комментариев к ним, большая часть из
них очевидны. Больше мы к этому не возвращаемся. Поищите информацию в интернете,
если оно вам надо.

    xcb_map_window(m_pXCBConn, m_xcbWindow);
    xcb_flush (m_pXCBConn);
}

Чтобы сделать окно видимым мы должны его отобразить и заставить сервер вывести
буфер на экран. Вот этим два вызова выше и занимаются.

VkSurfaceKHR XCBControl::CreateSurface(VkInstance& inst)
{
    VkXcbSurfaceCreateInfoKHR surfaceCreateInfo = {};
    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
    surfaceCreateInfo.connection = m_pXCBConn;
    surfaceCreateInfo.window = m_xcbWindow;

    VkSurfaceKHR surface;

    VkResult res = vkCreateXcbSurfaceKHR(inst, &surfaceCreateInfo, NULL, &surface);
    CHECK_VULKAN_ERROR("vkCreateXcbSurfaceKHR error %dn", res);

    return surface;
}

Последняя функция из класса XCBControl, на которую мы обратим внимание, — это
CreateSurface(). По сути это декоратор функции Vulkan vkCreateXcbSurfaceKHR().
Мы заполняем структуру VkXcbSurfaceCreateInfoKHR указателем на соединение
с сервером XWindow и созданным ранее окном. В ответ мы получим поверхность Vulkan,
которую сразу же передаем назад вызвавшей функции.

Давайте теперь рассмотрим аналогичный класс для Windows:

class Win32Control : public VulkanWindowControl
{
public:
    Win32Control(const char* pAppName);

    ~Win32Control();

    virtual void Init(uint Width, uint Height);

    virtual VkSurfaceKHR CreateSurface(VkInstance& inst);

 private:

    HINSTANCE   m_hinstance;
    HWND        m_hwnd;
    std::wstring m_appName;
};

Как вы видите, интерфейс для обеих ОС очень похож. По факту, Init() и
CreateSurface() идентичны так как они виртуальные функции. Мы также
добавили приватные свойства для записи специфических для Windows данных —
HINSTANE и HWND.

Win32Control::Win32Control(const char* pAppName)
{
    m_hinstance = GetModuleHandle(NULL);;
    assert(m_hinstance);
    m_hwnd = 0;
    **std::string s(pAppName)**;
    m_appName = **std::wstring(s.begin(), s.end())**;
}

Выше показан конструктор класса Win32Control, который я привожу только для
того, что бы вы знали как преобразовывается название окна из массива букв в
std::wstring. Мы делаем это для функции CreateWindowEx(), которой название
окна требуется в виде типа LPCTSTR. Стандартный класс wstring нам в этом
пригодится.

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

void Win32Control::Init(uint Width, uint Height)
{
    WNDCLASSEX wndcls = {};

    wndcls.cbSize = sizeof(wndcls);
    wndcls.lpfnWndProc = WindowProc;
    wndcls.hInstance = m_hinstance;
    wndcls.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wndcls.lpszClassName = L"ogldev";

    if (!RegisterClassEx(&wndcls)) {
        DWORD error = GetLastError();
        OGLDEV_ERROR("RegisterClassEx error %d", error);
    }

    m_hwnd = CreateWindowEx(0,
                            L"ogldev",                        // название
                            m_appName.c_str(),
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE, // стиль окна
                            100, 100,                         // начальное положение
                            Width,
                            Height,
                            NULL,
                            NULL,
                            m_hinstance,
                            NULL);

    if (m_hwnd == 0) {
        DWORD error = GetLastError();
        OGLDEV_ERROR("CreateWindowEx error %d", error);
    }

    ShowWindow(m_hwnd, SW_SHOW);
}

Код выше, который создает окно, я нашел на MSDN, поэтому я не буду сильно
вдаваться в детали. Мы регистрируем окно через RegisterClassEx(). Окно будет
иметь связь с функцией WindowProc() — обработчиком событий. Прямо сейчас мы
используем стандартный обработчик, но в следующих уроках мы добавим больше
деталей. Окно создается функцией CreateWindowEx() и, наконец, отображается
через ShowWindow().

VkSurfaceKHR Win32Control::CreateSurface(VkInstance& inst)
{
    VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
    surfaceCreateInfo.hinstance = m_hinstance;
    surfaceCreateInfo.hwnd = m_hwnd;

    VkSurfaceKHR surface;

    VkResult res = vkCreateWin32SurfaceKHR(inst, &surfaceCreateInfo, NULL, &surface);
    CHECK_VULKAN_ERROR("vkCreateXcbSurfaceKHR error %dn", res);

    return surface;
}

CreateSurface() тоже очень похожа на аналог для Linux. Параметр
surfaceCreateInfo здесь представляет собой экземпляр (и, конечно же,
обработчики windows имеют другие типы).

int main(int argc, char** argv)
{
    VulkanWindowControl* pWindowControl = NULL;
#ifdef WIN32
    pWindowControl = new Win32Control(pAppName);
#else
    pWindowControl = new XCBControl();
#endif
    pWindowControl->Init(WINDOW_WIDTH, WINDOW_HEIGHT);

    OgldevVulkanCore core("tutorial 50");
    core.Init(pWindowControl);

    return 0;
}

Наконец мы подошли к связыванию всего кода в функции main(). Если есть желание,
то вы можете начать отсюда и постепенно добавлять блоки кода, проверяя какие
значения будет для них возвращать Vulkan. Всё в этой функции уже было подробно
рассмотрено. Мы выделяем память для реализации класса VulkanWindowControl
(для Linux или Windows), а затем создает и инициализируем объект
OgldevVulkanCore. Теперь у нас есть связанная с окном ОС поверхность Vulkan,
экземпляр Vulkan, устройство и база данных со всеми физическими устройствами.

Надеюсь что вам этот урок пригодился. Кстати, вместе с ним полагается футболка
с надписью «Я написал тону кода на Vulkan, а получил пустое окно». Действительно,
мы проделали большой путь, а ничего так и не отрендерели. Но не отчаивайтесь.
У нас есть базовая структура с несколькими объектами ядра Vulkan. В следующем
уроке мы продолжим работать над ним, так что не переключайтесь.