Support both quad and linear derivative group modes in compute shader derivatives sample

Enhances the compute shader derivatives sample to support both derivative group modes (quads and linear) with runtime fallback. Splits shader into two variants (quad/linear), selects appropriate shader based on device capabilities, and prioritizes quads when available. Adds validation for required storage image features and updates documentation to clarify KHR extension requirement over deprecated NV variant.

Author: gpx1000

samples/extensions/compute_shader_derivatives/CMakeLists.txt

@@ -26,7 +26,8 @@ add_sample(
     NAME "Compute shader derivatives"
     DESCRIPTION "Demonstrates VK_KHR_compute_shader_derivatives with a minimal compute dispatch using dFdx/dFdy in compute"
     SHADER_FILES_SLANG
-        "compute_shader_derivatives/slang/derivatives.comp.slang"
+        "compute_shader_derivatives/slang/derivatives_quad.comp.slang"
+        "compute_shader_derivatives/slang/derivatives_linear.comp.slang"
         "compute_shader_derivatives/slang/fullscreen.vert.slang"
         "compute_shader_derivatives/slang/fullscreen.frag.slang"
     )

samples/extensions/compute_shader_derivatives/compute_shader_derivatives.cpp

@@ -32,10 +32,12 @@ ComputeShaderDerivatives::ComputeShaderDerivatives()
 
 	// Needed for feature chaining
 	add_instance_extension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
-	// Device extension providing the feature
+	// Device extension providing the feature (KHR is required)
 	add_device_extension(VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME);
-	// Toolchains may still emit SPV_NV_compute_shader_derivatives; enable NV extension if available to satisfy validation
-	add_device_extension(VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, /*optional*/ true);
+	// Note for developers/tooling:
+	// If your shader compiler/toolchain only emits SPV_NV_compute_shader_derivatives instead of SPV_KHR,
+	// please update to a newer Vulkan SDK, glslang, and SPIR-V Tools that support the KHR variant.
+	// This sample intentionally does not enable the NV extension and only targets VK_KHR_compute_shader_derivatives.
 	// Shader draw parameters (required for SV_VertexID in Slang-generated vertex shader SPIR-V)
 	add_device_extension(VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, /*optional*/ true);
 }
@@ -172,13 +174,28 @@ void ComputeShaderDerivatives::create_output_buffer_and_descriptors()
 
 void ComputeShaderDerivatives::request_gpu_features(vkb::core::PhysicalDeviceC &gpu)
 {
-	// Require quads derivative group (the sample shader uses layout(derivative_group_quadsNV/derivative_group_quads_khr))
-	REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, computeDerivativeGroupQuads);
-	// Users may switch to the linear mode by changing the shader qualifier
+	// Request both derivative group modes as OPTIONAL, prefer Quads if available at runtime.
+	// Some implementations only support computeDerivativeGroupLinear.
+	REQUEST_OPTIONAL_FEATURE(gpu, VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, computeDerivativeGroupQuads);
+	REQUEST_OPTIONAL_FEATURE(gpu, VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, computeDerivativeGroupLinear);
 
 	// Storage image read/write without format (required for storage images without explicit format qualifiers)
-	gpu.get_mutable_requested_features().shaderStorageImageReadWithoutFormat  = VK_TRUE;
-	gpu.get_mutable_requested_features().shaderStorageImageWriteWithoutFormat = VK_TRUE;
+	if (gpu.get_features().shaderStorageImageReadWithoutFormat)
+	{
+		gpu.get_mutable_requested_features().shaderStorageImageReadWithoutFormat = VK_TRUE;
+	}
+	else
+	{
+		throw std::runtime_error("GPU does not support shaderStorageImageReadWithoutFormat feature, which is required for this sample.");
+	}
+	if (gpu.get_features().shaderStorageImageWriteWithoutFormat)
+	{
+		gpu.get_mutable_requested_features().shaderStorageImageWriteWithoutFormat = VK_TRUE;
+	}
+	else
+	{
+		throw std::runtime_error("GPU does not support shaderStorageImageWriteWithoutFormat feature, which is required for this sample.");
+	}
 }
 
 void ComputeShaderDerivatives::create_compute_pipeline()
@@ -230,8 +247,11 @@ void ComputeShaderDerivatives::create_compute_pipeline()
 
 	vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
 
-	// Load compute shader
-	VkPipelineShaderStageCreateInfo stage = load_shader("compute_shader_derivatives/slang/derivatives.comp.spv", VK_SHADER_STAGE_COMPUTE_BIT);
+	// Load compute shader based on selected derivative group mode
+	const char *comp_path = use_quads_ ?
+	                        "compute_shader_derivatives/slang/derivatives_quad.comp.spv" :
+	                        "compute_shader_derivatives/slang/derivatives_linear.comp.spv";
+	VkPipelineShaderStageCreateInfo stage = load_shader(comp_path, VK_SHADER_STAGE_COMPUTE_BIT);
 
 	VkComputePipelineCreateInfo compute_ci{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
 	compute_ci.stage  = stage;
@@ -361,15 +381,29 @@ void ComputeShaderDerivatives::create_graphics_pipeline()
 
 bool ComputeShaderDerivatives::prepare(const vkb::ApplicationOptions &options)
 {
-	if (!ApiVulkanSample::prepare(options))
+    if (!ApiVulkanSample::prepare(options))
+    {
+        return false;
+    }
+
+	// Decide which derivative group to use at runtime based on enabled device features.
+	// Prefer Quads when available; otherwise, fall back to Linear.
+	VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR csd_features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR};
+	VkPhysicalDeviceFeatures2                            features2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
+	features2.pNext = &csd_features;
+	vkGetPhysicalDeviceFeatures2(get_device().get_gpu().get_handle(), &features2);
+	use_quads_ = (csd_features.computeDerivativeGroupQuads == VK_TRUE);
+	if (!use_quads_ && csd_features.computeDerivativeGroupLinear != VK_TRUE)
 	{
+		// Neither mode is available: cannot run this sample.
+		LOGE("VK_KHR_compute_shader_derivatives present but neither quads nor linear derivative groups are reported as supported.");
 		return false;
 	}
 
-	// Create resources in order: image, buffer, then pipelines
-	create_storage_image();
-	create_output_buffer_and_descriptors();
-	create_compute_pipeline();
+    // Create resources in order: image, buffer, then pipelines
+    create_storage_image();
+    create_output_buffer_and_descriptors();
+    create_compute_pipeline();
 	create_graphics_pipeline();
 
 	prepared = true;

samples/extensions/compute_shader_derivatives/compute_shader_derivatives.h

@@ -39,6 +39,10 @@ class ComputeShaderDerivatives : public ApiVulkanSample
 	void create_compute_pipeline();
 	void create_graphics_pipeline();
 
+	// Which derivative group mode the sample will use at runtime.
+	// Prefer quads when available; otherwise fall back to linear.
+	bool use_quads_{false};
+
 	// Image dimensions for visualization
 	static constexpr uint32_t image_width{512};
 	static constexpr uint32_t image_height{512};

shaders/compute_shader_derivatives/slang/derivatives_linear.comp.slang

@@ -0,0 +1,68 @@
+/* Copyright (c) 2026, Holochip Inc
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 the "License";
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Compute shader demonstrating derivatives in compute (Linear mode).
+// Many implementations only support computeDerivativeGroupLinear.
+// Mapping 1D lanes to 2D coordinates for linear groups follows the DX SM 6.6 spec:
+// https://microsoft.github.io/DirectX-Specs/d3d/HLSL_SM_6_6_Derivatives.html
+// Intuition: lanes are ordered linearly across the group; hardware derives a
+// consistent local 2D mapping to evaluate ddx/ddy even when quads aren't supported.
+// Note: ddx/ddy in compute require VK_KHR_compute_shader_derivatives at runtime.
+// Tooling note: If your toolchain emits SPV_NV_compute_shader_derivatives instead of SPV_KHR,
+// please update to a newer Vulkan SDK, glslang, and SPIR-V Tools that support the KHR variant.
+
+// Output image for gradient magnitude visualization
+[[vk::binding(0, 0)]] RWTexture2D<float4> gOutputImage : register(u0, space0);
+
+// 8x8 local size; derivative groups are defined by implementation in Linear mode
+[shader("compute")]
+[numthreads(8, 8, 1)]
+[DerivativeGroupLinear]  // Enable linear-based derivative computation
+void main(uint3 tid : SV_DispatchThreadID)
+{
+    // Get image dimensions
+    uint2 dims;
+    gOutputImage.GetDimensions(dims.x, dims.y);
+    
+    if (tid.x >= dims.x || tid.y >= dims.y)
+        return;
+    
+    // Normalized coordinates [0, 1]
+    float2 uv = float2(tid.xy) / float2(dims - 1);
+    
+    // Procedural function (same as Quad variant) to produce identical output
+    float2 center = float2(0.5, 0.5);
+    float2 delta = uv - center;
+    float dist = length(delta);
+    
+    float value = sin(dist * 10.0) * 0.5 + 0.5;
+    value *= (1.0 - smoothstep(0.0, 0.7, dist));
+    
+    // Derivatives of the function
+    float dx = ddx(value);
+    float dy = ddy(value);
+    
+    float gradientMag = sqrt(dx * dx + dy * dy);
+    float edgeIntensity = saturate(gradientMag * 10.0);
+    
+    float3 color;
+    color.r = edgeIntensity;
+    color.g = edgeIntensity * 0.5;
+    color.b = value * (1.0 - edgeIntensity);
+    
+    gOutputImage[tid.xy] = float4(color, 1.0);
+}

shaders/compute_shader_derivatives/slang/derivatives_linear.comp.spv

@@ -15,10 +15,12 @@
  * limitations under the License.
  */
 
-// Compute shader demonstrating derivatives in compute with a practical use case.
+// Compute shader demonstrating derivatives in compute (Quad mode).
 // This shader computes a procedural 2D function and uses derivatives to calculate
 // gradient magnitude - demonstrating edge detection and spatial analysis capabilities.
 // Note: ddx/ddy in compute require VK_KHR_compute_shader_derivatives at runtime.
+// Tooling note: If your toolchain emits SPV_NV_compute_shader_derivatives instead of SPV_KHR,
+// please update to a newer Vulkan SDK, glslang, and SPIR-V Tools that support the KHR variant.
 
 // Output image for gradient magnitude visualization
 [[vk::binding(0, 0)]] RWTexture2D<float4> gOutputImage : register(u0, space0);
@@ -40,7 +42,6 @@ void main(uint3 tid : SV_DispatchThreadID)
     float2 uv = float2(tid.xy) / float2(dims - 1);
 
     // Create an interesting procedural function: radial gradient with modulation
-    // This demonstrates a practical use case for derivatives in compute
     float2 center = float2(0.5, 0.5);
     float2 delta = uv - center;
     float dist = length(delta);
@@ -50,21 +51,16 @@ void main(uint3 tid : SV_DispatchThreadID)
     value *= (1.0 - smoothstep(0.0, 0.7, dist));
 
     // Compute derivatives of the function - this is the key feature!
-    // These derivatives tell us how quickly the function changes spatially
     float dx = ddx(value);
     float dy = ddy(value);
 
     // Gradient magnitude - useful for edge detection, LOD selection, and filtering
-    // High gradient = rapid spatial changes (edges)
     float gradientMag = sqrt(dx * dx + dy * dy);
 
     // Visualize gradient magnitude as edge detection
-    // Scale up the gradient for better visibility
     float edgeIntensity = saturate(gradientMag * 10.0);
 
-    // Create a color visualization:
-    // - Base pattern in blue channel
-    // - Edges (high gradient) in red/yellow
+    // Create a color visualization
     float3 color;
     color.r = edgeIntensity;                    // Red for edges
     color.g = edgeIntensity * 0.5;              // Some yellow for strong edges