Use optional Vulkan12Features::shaderBufferInt64Atomics feature for better mouse picking precision.

Author: stripe2933

CMakeLists.txt

@@ -296,14 +296,21 @@ target_link_shaders(vk-gltf-viewer PRIVATE
         shaders/jump_flood_seed.vert
         shaders/jump_flood.comp
         shaders/multi_node_mouse_picking.frag
-        shaders/node_mouse_picking.frag
         shaders/node_mouse_picking.vert
         shaders/outline.frag
         shaders/screen_quad.vert
         shaders/skybox.frag
         shaders/skybox.vert
 )
 
+target_link_shader_variants(vk-gltf-viewer PRIVATE
+    TARGET_ENV vulkan1.2
+    MACRO_DEFS "SEPARATE_IMAGE_SAMPLER=$<PLATFORM_ID:Darwin>"
+    FILES
+        shaders/node_mouse_picking.frag
+    MACRO_NAMES "KHR_SHADER_ATOMIC_INT64"
+    MACRO_VALUES 0 1
+)
 target_link_shader_variants(vk-gltf-viewer PRIVATE
     TARGET_ENV vulkan1.2
     FILES
@@ -314,13 +321,22 @@ target_link_shader_variants(vk-gltf-viewer PRIVATE
         "0 0" "0 1"
         "1 0" "1 1"
 )
+target_link_shader_variants(vk-gltf-viewer PRIVATE
+    TARGET_ENV vulkan1.2
+    MACRO_DEFS "SEPARATE_IMAGE_SAMPLER=$<PLATFORM_ID:Darwin>"
+    FILES
+        shaders/mask_node_mouse_picking.frag
+    MACRO_NAMES "HAS_BASE_COLOR_TEXTURE" "HAS_COLOR_0_ALPHA_ATTRIBUTE" "KHR_SHADER_ATOMIC_INT64"
+    MACRO_VALUES
+        "0 0 0" "0 0 1" "0 1 0" "0 1 1"
+        "1 0 0" "1 0 1" "1 1 0" "1 1 1"
+)
 target_link_shader_variants(vk-gltf-viewer PRIVATE
     TARGET_ENV vulkan1.2
     MACRO_DEFS "SEPARATE_IMAGE_SAMPLER=$<PLATFORM_ID:Darwin>"
     FILES
         shaders/mask_jump_flood_seed.frag
         shaders/mask_multi_node_mouse_picking.frag
-        shaders/mask_node_mouse_picking.frag
     MACRO_NAMES "HAS_BASE_COLOR_TEXTURE" "HAS_COLOR_0_ALPHA_ATTRIBUTE"
     MACRO_VALUES
         "0 0" "0 1"

README.md

@@ -121,6 +121,7 @@ The extensions and feature used in this application are quite common in the mode
     - `timelineSemaphore`
     - `shaderInt8`
     - (optional) `drawIndirectCount` (If not presented, GPU frustum culling will be unavailable and fallback to the CPU frustum culling.)
+    - (optional) `shaderBufferInt64Atomics` (better mouse picking precision)
   - `VkPhysicalDeviceDynamicRenderingFeatures`
   - `VkPhysicalDeviceSynchronization2Features`
   - `VkPhysicalDeviceExtendedDynamicStateFeaturesEXT`

impl/vulkan/Frame.cpp

@@ -69,7 +69,7 @@ vk_gltf_viewer::vulkan::Frame::GltfAsset::GltfAsset(const SharedData &sharedData
         sharedData.gpu.allocator,
         vk::BufferCreateInfo {
             {},
-            sizeof(std::uint32_t) * math::divCeil<std::uint32_t>(assetExtended->asset.nodes.size(), 32U),
+            std::max(sizeof(std::uint64_t), sizeof(std::uint32_t) * math::divCeil<std::uint32_t>(assetExtended->asset.nodes.size(), 32U)),
             vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer,
         },
         vma::AllocationCreateInfo {
@@ -148,8 +148,15 @@ vk_gltf_viewer::vulkan::Frame::ExecutionResult vk_gltf_viewer::vulkan::Frame::ge
                 }
             },
             [&](const vk::Offset2D&) {
-                const std::uint32_t packedNodeIndexAndDepth = gltfAsset->mousePickingResultBuffer.asValue<const std::uint32_t>();
-                if (std::uint32_t nodeIndex = packedNodeIndexAndDepth & 0xFFFF; nodeIndex != NO_INDEX) {
+                std::uint32_t nodeIndex;
+                if (sharedData.gpu.supportShaderBufferInt64Atomics) {
+                    nodeIndex = gltfAsset->mousePickingResultBuffer.asValue<const std::uint64_t>() & 0xFFFF;
+                }
+                else {
+                    nodeIndex = gltfAsset->mousePickingResultBuffer.asValue<const std::uint32_t>() & 0xFFFF;
+                }
+
+                if (nodeIndex != NO_INDEX) {
                     result.mousePickingResult.emplace<std::size_t>(nodeIndex);
                 }
             },
@@ -1218,7 +1225,12 @@ void vk_gltf_viewer::vulkan::Frame::recordScenePrepassCommands(vk::CommandBuffer
     // Mouse picking.
     const bool makeMousePickingResultBufferAvailableToHost = renderingNodes && visit(multilambda {
         [&](const vk::Offset2D &offset) {
-            cb.updateBuffer<std::uint32_t>(gltfAsset->mousePickingResultBuffer, 0, NO_INDEX);
+            if (sharedData.gpu.supportShaderBufferInt64Atomics) {
+                cb.updateBuffer<std::uint64_t>(gltfAsset->mousePickingResultBuffer, 0, NO_INDEX);
+            }
+            else {
+                cb.updateBuffer<std::uint32_t>(gltfAsset->mousePickingResultBuffer, 0, NO_INDEX);
+            }
 
             if (renderingNodes->startMousePickingRenderPass) {
                 cb.pipelineBarrier(

impl/vulkan/Gpu.cpp

@@ -235,6 +235,7 @@ vk::raii::Device vk_gltf_viewer::vulkan::Gpu::createDevice() {
         vk::PhysicalDeviceVulkan12Features,
         vk::PhysicalDeviceIndexTypeUint8FeaturesKHR>();
 
+    supportShaderBufferInt64Atomics = vulkan12Features.shaderBufferInt64Atomics;
     supportDrawIndirectCount = vulkan12Features.drawIndirectCount;
 #if __APPLE__
     // MoltenVK supports VK_KHR_index_type_uint8 from v1.3.0 by dynamically generating 16-bit indices from 8-bit indices
@@ -270,7 +271,10 @@ vk::raii::Device vk_gltf_viewer::vulkan::Gpu::createDevice() {
             {},
             extensions,
         },
-        vk::PhysicalDeviceFeatures2 { requiredFeatures },
+        vk::PhysicalDeviceFeatures2 {
+            vk::PhysicalDeviceFeatures { requiredFeatures }
+                .setShaderInt64(supportShaderBufferInt64Atomics),
+        },
         vk::PhysicalDeviceVulkan11Features{}
             .setShaderDrawParameters(true)
             .setStorageBuffer16BitAccess(true)
@@ -288,7 +292,8 @@ vk::raii::Device vk_gltf_viewer::vulkan::Gpu::createDevice() {
             .setScalarBlockLayout(true)
             .setTimelineSemaphore(true)
             .setShaderInt8(true)
-            .setDrawIndirectCount(supportDrawIndirectCount),
+            .setDrawIndirectCount(supportDrawIndirectCount)
+            .setShaderBufferInt64Atomics(supportShaderBufferInt64Atomics),
         vk::PhysicalDeviceDynamicRenderingFeatures { true },
         vk::PhysicalDeviceSynchronization2Features { true },
         vk::PhysicalDeviceExtendedDynamicStateFeaturesEXT { true },

interface/shader_selector/mask_node_mouse_picking_frag.cppm

@@ -7,18 +7,19 @@ import vk_gltf_viewer.shader.mask_node_mouse_picking_frag;
 
 namespace vk_gltf_viewer::shader_selector {
     export
-    [[nodiscard]] std::span<const unsigned int> mask_node_mouse_picking_frag(int HAS_BASE_COLOR_TEXTURE, int HAS_COLOR_0_ALPHA_ATTRIBUTE);
+    [[nodiscard]] std::span<const unsigned int> mask_node_mouse_picking_frag(int HAS_BASE_COLOR_TEXTURE, int HAS_COLOR_0_ALPHA_ATTRIBUTE, int KHR_SHADER_ATOMIC_INT64);
 }
 
 #if !defined(__GNUC__) || defined(__clang__)
 module :private;
 #endif
 
-std::span<const unsigned int> vk_gltf_viewer::shader_selector::mask_node_mouse_picking_frag(int HAS_BASE_COLOR_TEXTURE, int HAS_COLOR_0_ALPHA_ATTRIBUTE) {
+std::span<const unsigned int> vk_gltf_viewer::shader_selector::mask_node_mouse_picking_frag(int HAS_BASE_COLOR_TEXTURE, int HAS_COLOR_0_ALPHA_ATTRIBUTE, int KHR_SHADER_ATOMIC_INT64) {
     return std::visit(
         [](auto... Is) -> std::span<const unsigned int> {
             return shader::mask_node_mouse_picking_frag<Is...>;
         },
         iota_map<2>::get_variant(HAS_BASE_COLOR_TEXTURE),
-        iota_map<2>::get_variant(HAS_COLOR_0_ALPHA_ATTRIBUTE));
+        iota_map<2>::get_variant(HAS_COLOR_0_ALPHA_ATTRIBUTE),
+        iota_map<2>::get_variant(KHR_SHADER_ATOMIC_INT64));
 }

interface/vulkan/Gpu.cppm

@@ -59,6 +59,7 @@ namespace vk_gltf_viewer::vulkan {
 
         bool isUmaDevice;
         bool supportSwapchainMutableFormat;
+        bool supportShaderBufferInt64Atomics;
         bool supportDrawIndirectCount;
         bool supportUint8Index;
         bool supportAttachmentFeedbackLoopLayout;

interface/vulkan/pipeline/NodeMousePickingRenderPipeline.cppm

@@ -50,7 +50,7 @@ namespace vk_gltf_viewer::vulkan::inline pipeline {
 
         [[nodiscard]] static std::array<int, 2> getVertexShaderVariants(const PrepassPipelineConfig<true> &config) noexcept;
         [[nodiscard]] static VertexShaderSpecialization getVertexShaderSpecialization(const PrepassPipelineConfig<true> &config) noexcept;
-        [[nodiscard]] static std::array<int, 2> getFragmentShaderVariants(const PrepassPipelineConfig<true> &config) noexcept;
+        [[nodiscard]] static std::array<int, 3> getFragmentShaderVariants(const PrepassPipelineConfig<true> &config, bool supportShaderBufferInt64Atomics) noexcept;
         [[nodiscard]] static FragmentShaderSpecialization getFragmentShaderSpecialization(const PrepassPipelineConfig<true> &config) noexcept;
     };
 }
@@ -88,7 +88,12 @@ vk_gltf_viewer::vulkan::pipeline::NodeMousePickingRenderPipeline<false>::NodeMou
                             vku::unsafeProxy(getVertexShaderSpecialization(config)),
                         }),
                     },
-                    vku::Shader { shader::node_mouse_picking_frag, vk::ShaderStageFlagBits::eFragment }).get(),
+                    vku::Shader {
+                        gpu.supportShaderBufferInt64Atomics
+                            ? std::span<const std::uint32_t> { shader::node_mouse_picking_frag<1> }
+                            : std::span<const std::uint32_t> { shader::node_mouse_picking_frag<0> },
+                        vk::ShaderStageFlagBits::eFragment,
+                    }).get(),
                 // See doc about Gpu::Workaround::attachmentLessRenderPass.
                 *pipelineLayout, 0, gpu.workaround.attachmentLessRenderPass)
                 .setPInputAssemblyState(vku::unsafeAddress(vk::PipelineInputAssemblyStateCreateInfo {
@@ -157,7 +162,7 @@ vk_gltf_viewer::vulkan::pipeline::NodeMousePickingRenderPipeline<true>::NodeMous
                         }),
                     },
                     vku::Shader {
-                        std::apply(LIFT(shader_selector::mask_node_mouse_picking_frag), getFragmentShaderVariants(config)),
+                        std::apply(LIFT(shader_selector::mask_node_mouse_picking_frag), getFragmentShaderVariants(config, gpu.supportShaderBufferInt64Atomics)),
                         vk::ShaderStageFlagBits::eFragment,
                         vku::unsafeAddress(vk::SpecializationInfo {
                             SpecializationMap<FragmentShaderSpecialization>::value,
@@ -215,12 +220,14 @@ auto vk_gltf_viewer::vulkan::pipeline::NodeMousePickingRenderPipeline<true>::get
     return result;
 }
 
-std::array<int, 2> vk_gltf_viewer::vulkan::pipeline::NodeMousePickingRenderPipeline<true>::getFragmentShaderVariants(
-    const PrepassPipelineConfig<true> &config
+std::array<int, 3> vk_gltf_viewer::vulkan::pipeline::NodeMousePickingRenderPipeline<true>::getFragmentShaderVariants(
+    const PrepassPipelineConfig<true> &config,
+    bool supportShaderBufferInt64Atomics
 ) noexcept {
     return {
         config.baseColorTexcoordComponentTypeAndNormalized.has_value(),
         config.color0AlphaComponentType.has_value(),
+        supportShaderBufferInt64Atomics,
     };
 }
 

shaders/mask_node_mouse_picking.frag

@@ -3,6 +3,10 @@
 #extension GL_EXT_nonuniform_qualifier : require
 #extension GL_EXT_shader_16bit_storage : require
 #extension GL_EXT_shader_8bit_storage : require
+#if KHR_SHADER_ATOMIC_INT64 == 1
+#extension GL_EXT_shader_atomic_int64 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require
+#endif
 
 #define FRAGMENT_SHADER
 #include "indexing.glsl"
@@ -36,7 +40,11 @@ layout (set = 0, binding = 3) uniform sampler2D textures[];
 #endif
 
 layout (set = 1, binding = 0) buffer MousePickingResultBuffer {
+#if KHR_SHADER_ATOMIC_INT64 == 1
+    uint64_t packedNodeIndexAndDepth;
+#else
     uint packedNodeIndexAndDepth;
+#endif
 };
 
 void main(){
@@ -57,5 +65,9 @@ void main(){
 #endif
     if (baseColorAlpha < MATERIAL.alphaCutoff) discard;
 
+#if KHR_SHADER_ATOMIC_INT64 == 1
+    atomicMax(packedNodeIndexAndDepth, packUint2x32(uvec2(inNodeIndex, floatBitsToUint(gl_FragCoord.z))));
+#else
     atomicMax(packedNodeIndexAndDepth, (uint(gl_FragCoord.z * 65535) << 16) | inNodeIndex);
+#endif
 }

shaders/node_mouse_picking.frag

@@ -1,11 +1,23 @@
 #version 450
+#if KHR_SHADER_ATOMIC_INT64 == 1
+#extension GL_EXT_shader_atomic_int64 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int64 : require
+#endif
 
 layout (location = 0) flat in uint inNodeIndex;
 
 layout (set = 1, binding = 0) buffer MousePickingResultBuffer {
+#if KHR_SHADER_ATOMIC_INT64 == 1
+    uint64_t packedNodeIndexAndDepth;
+#else
     uint packedNodeIndexAndDepth;
+#endif
 };
 
 void main(){
+#if KHR_SHADER_ATOMIC_INT64 == 1
+    atomicMax(packedNodeIndexAndDepth, packUint2x32(uvec2(inNodeIndex, floatBitsToUint(gl_FragCoord.z))));
+#else
     atomicMax(packedNodeIndexAndDepth, (uint(gl_FragCoord.z * 65535) << 16) | inNodeIndex);
+#endif
 }